text: // REQUIRES: aarch64-registered-target || arm-registered-target
  
  // RUN: %clang_cc1 -triple arm64-none-eabi -target-feature +neon -target-feature +dotprod -target-feature +v8.1a -verify %s
  // RUN: %clang_cc1 -triple armv8.1a-none-eabi -target-feature +neon -target-feature +dotprod -target-feature +v8.1a -verify %s
  
  #include <arm_neon.h>
  
  void test_vdot_lane(int32x2_t r, int8x8_t a, int8x8_t b) {
    vdot_lane_s32(r, a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vdot_lane_s32(r, a, b, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vdot_lane_s32(r, a, b, 0);
    vdot_lane_s32(r, a, b, 1);
  }
  
  void test_vdotq_lane(int32x4_t r, int8x16_t a, int8x8_t b) {
    vdotq_lane_s32(r, a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vdotq_lane_s32(r, a, b, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vdotq_lane_s32(r, a, b, 0);
    vdotq_lane_s32(r, a, b, 1);
  }
  
  #if defined(__aarch64__)
  void test_vdot_laneq(int32x2_t r, int8x8_t a, int8x16_t b) {
    vdot_laneq_s32(r, a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vdot_laneq_s32(r, a, b, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vdot_laneq_s32(r, a, b, 0);
    vdot_laneq_s32(r, a, b, 3);
  }
  
  void test_vdotq_laneq(int32x4_t r, int8x16_t a, int8x16_t b) {
    vdotq_laneq_s32(r, a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vdotq_laneq_s32(r, a, b, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vdotq_laneq_s32(r, a, b, 0);
    vdotq_laneq_s32(r, a, b, 3);
  }
  #endif
  
  void test_vdup_lane(int32x2_t v) {
    vdup_lane_s32(v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vdup_lane_s32(v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vdup_lane_s32(v, 0);
    vdup_lane_s32(v, 1);
  }
  
  void test_vdupq_lane(int32x2_t v) {
    vdupq_lane_s32(v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vdupq_lane_s32(v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vdupq_lane_s32(v, 0);
    vdupq_lane_s32(v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vdup_laneq(int32x4_t v) {
    vdup_laneq_s32(v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vdup_laneq_s32(v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vdup_laneq_s32(v, 0);
    vdup_laneq_s32(v, 3);
  }
  
  void test_vdupq_laneq(int32x4_t v) {
    vdupq_laneq_s32(v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vdupq_laneq_s32(v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vdupq_laneq_s32(v, 0);
    vdupq_laneq_s32(v, 3);
  }
  #endif
  
  void test_vmla_lane(int32x2_t a, int32x2_t b, int32x2_t v) {
    vmla_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmla_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmla_lane_s32(a, b, v, 0);
    vmla_lane_s32(a, b, v, 1);
  }
  
  void test_vmlaq_lane(int32x4_t a, int32x4_t b, int32x2_t v) {
    vmlaq_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmlaq_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmlaq_lane_s32(a, b, v, 0);
    vmlaq_lane_s32(a, b, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vmla_laneq(int32x2_t a, int32x2_t b, int32x4_t v) {
    vmla_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmla_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmla_laneq_s32(a, b, v, 0);
    vmla_laneq_s32(a, b, v, 3);
  }
  
  void test_vmlaq_laneq(int32x4_t a, int32x4_t b, int32x4_t v) {
    vmlaq_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmlaq_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmlaq_laneq_s32(a, b, v, 0);
    vmlaq_laneq_s32(a, b, v, 3);
  }
  
  void test_vmlal_high_lane(int64x2_t a, int32x4_t b, int32x2_t v) {
    vmlal_high_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmlal_high_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmlal_high_lane_s32(a, b, v, 0);
    vmlal_high_lane_s32(a, b, v, 1);
  }
  
  void test_vmlal_high_laneq(int64x2_t a, int32x4_t b, int32x4_t v) {
    vmlal_high_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmlal_high_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmlal_high_laneq_s32(a, b, v, 0);
    vmlal_high_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vmlal_lane(int64x2_t a, int32x2_t b, int32x2_t v) {
    vmlal_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmlal_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmlal_lane_s32(a, b, v, 0);
    vmlal_lane_s32(a, b, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vmlal_laneq(int64x2_t a, int32x2_t b, int32x4_t v) {
    vmlal_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmlal_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmlal_laneq_s32(a, b, v, 0);
    vmlal_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vmls_lane(int32x2_t a, int32x2_t b, int32x2_t v) {
    vmls_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmls_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmls_lane_s32(a, b, v, 0);
    vmls_lane_s32(a, b, v, 1);
  }
  
  void test_vmlsq_lane(int32x4_t a, int32x4_t b, int32x2_t v) {
    vmlsq_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmlsq_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmlsq_lane_s32(a, b, v, 0);
    vmlsq_lane_s32(a, b, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vmls_laneq(int32x2_t a, int32x2_t b, int32x4_t v) {
    vmls_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmls_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmls_laneq_s32(a, b, v, 0);
    vmls_laneq_s32(a, b, v, 3);
  }
  
  void test_vmlsq_laneq(int32x4_t a, int32x4_t b, int32x4_t v) {
    vmlsq_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmlsq_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmlsq_laneq_s32(a, b, v, 0);
    vmlsq_laneq_s32(a, b, v, 3);
  }
  
  void test_vmlsl_high_lane(int64x2_t a, int32x4_t b, int32x2_t v) {
    vmlsl_high_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmlsl_high_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmlsl_high_lane_s32(a, b, v, 0);
    vmlsl_high_lane_s32(a, b, v, 1);
  }
  
  void test_vmlsl_high_laneq(int64x2_t a, int32x4_t b, int32x4_t v) {
    vmlsl_high_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmlsl_high_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmlsl_high_laneq_s32(a, b, v, 0);
    vmlsl_high_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vmlsl_lane(int64x2_t a, int32x2_t b, int32x2_t v) {
    vmlsl_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmlsl_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmlsl_lane_s32(a, b, v, 0);
    vmlsl_lane_s32(a, b, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vmlsl_laneq(int64x2_t a, int32x2_t b, int32x4_t v) {
    vmlsl_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmlsl_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmlsl_laneq_s32(a, b, v, 0);
    vmlsl_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vmull_lane(int32x2_t a, int32x2_t b) {
    vmull_lane_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmull_lane_s32(a, b, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmull_lane_s32(a, b, 0);
    vmull_lane_s32(a, b, 1);
  }
  
  #if defined(__aarch64__)
  void test_vmull_laneq(int32x2_t a, int32x4_t b) {
    vmull_laneq_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmull_laneq_s32(a, b, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmull_laneq_s32(a, b, 0);
    vmull_laneq_s32(a, b, 3);
  }
  
  void test_vmull_high_lane(int32x4_t a, int32x2_t b) {
    vmull_high_lane_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vmull_high_lane_s32(a, b, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vmull_high_lane_s32(a, b, 0);
    vmull_high_lane_s32(a, b, 1);
  }
  
  void test_vmull_high_laneq(int32x4_t a, int32x4_t b) {
    vmull_high_laneq_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vmull_high_laneq_s32(a, b, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vmull_high_laneq_s32(a, b, 0);
    vmull_high_laneq_s32(a, b, 3);
  }
  
  void test_vqdmlal_high_lane(int64x2_t a, int32x4_t b, int32x2_t v) {
    vqdmlal_high_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqdmlal_high_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqdmlal_high_lane_s32(a, b, v, 0);
    vqdmlal_high_lane_s32(a, b, v, 1);
  }
  
  void test_vqdmlal_high_laneq(int64x2_t a, int32x4_t b, int32x4_t v) {
    vqdmlal_high_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqdmlal_high_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqdmlal_high_laneq_s32(a, b, v, 0);
    vqdmlal_high_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vqdmlal_lane(int64x2_t a, int32x2_t b, int32x2_t v) {
    vqdmlal_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqdmlal_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqdmlal_lane_s32(a, b, v, 0);
    vqdmlal_lane_s32(a, b, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vqdmlal_laneq(int64x2_t a, int32x2_t b, int32x4_t v) {
    vqdmlal_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqdmlal_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqdmlal_laneq_s32(a, b, v, 0);
    vqdmlal_laneq_s32(a, b, v, 3);
  }
  
  void test_vqdmlsl_high_lane(int64x2_t a, int32x4_t b, int32x2_t v) {
    vqdmlsl_high_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqdmlsl_high_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqdmlsl_high_lane_s32(a, b, v, 0);
    vqdmlsl_high_lane_s32(a, b, v, 1);
  }
  
  void test_vqdmlsl_high_laneq(int64x2_t a, int32x4_t b, int32x4_t v) {
    vqdmlsl_high_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqdmlsl_high_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqdmlsl_high_laneq_s32(a, b, v, 0);
    vqdmlsl_high_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vqdmlsl_lane(int64x2_t a, int32x2_t b, int32x2_t v) {
    vqdmlsl_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqdmlsl_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqdmlsl_lane_s32(a, b, v, 0);
    vqdmlsl_lane_s32(a, b, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vqdmlsl_laneq(int64x2_t a, int32x2_t b, int32x4_t v) {
    vqdmlsl_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqdmlsl_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqdmlsl_laneq_s32(a, b, v, 0);
    vqdmlsl_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vqdmulh_lane(int32x2_t a, int32x2_t b) {
    vqdmulh_lane_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqdmulh_lane_s32(a, b, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqdmulh_lane_s32(a, b, 0);
    vqdmulh_lane_s32(a, b, 1);
  }
  
  void test_vqdmulhq_lane(int32x4_t a, int32x2_t b) {
    vqdmulhq_lane_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqdmulhq_lane_s32(a, b, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqdmulhq_lane_s32(a, b, 0);
    vqdmulhq_lane_s32(a, b, 1);
  }
  
  #if defined(__aarch64__)
  void test_vqdmulh_laneq(int32x2_t a, int32x4_t b) {
    vqdmulh_laneq_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqdmulh_laneq_s32(a, b, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqdmulh_laneq_s32(a, b, 0);
    vqdmulh_laneq_s32(a, b, 3);
  }
  
  void test_vqdmulhq_laneq(int32x4_t a, int32x4_t b) {
    vqdmulhq_laneq_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqdmulhq_laneq_s32(a, b, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqdmulhq_laneq_s32(a, b, 0);
    vqdmulhq_laneq_s32(a, b, 3);
  }
  
  void test_vqdmull_high_lane(int32x4_t a, int32x2_t b) {
    vqdmull_high_lane_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqdmull_high_lane_s32(a, b, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqdmull_high_lane_s32(a, b, 0);
    vqdmull_high_lane_s32(a, b, 1);
  }
  
  void test_vqdmull_high_laneq(int32x4_t a, int32x4_t b) {
    vqdmull_high_laneq_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqdmull_high_laneq_s32(a, b, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqdmull_high_laneq_s32(a, b, 0);
    vqdmull_high_laneq_s32(a, b, 3);
  }
  #endif
  
  void test_vqdmull_lane(int32x2_t a, int32x2_t v) {
    vqdmull_lane_s32(a, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqdmull_lane_s32(a, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqdmull_lane_s32(a, v, 0);
    vqdmull_lane_s32(a, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vqdmull_laneq(int32x2_t a, int32x4_t v) {
    vqdmull_laneq_s32(a, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqdmull_laneq_s32(a, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqdmull_laneq_s32(a, v, 0);
    vqdmull_laneq_s32(a, v, 3);
  }
  #endif
  
  void test_vqrdmlah_lane(int32x2_t a, int32x2_t b, int32x2_t v) {
    vqrdmlah_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqrdmlah_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqrdmlah_lane_s32(a, b, v, 0);
    vqrdmlah_lane_s32(a, b, v, 1);
  }
  
  void test_vqrdmlahq_lane(int32x4_t a, int32x4_t b, int32x2_t v) {
    vqrdmlahq_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqrdmlahq_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqrdmlahq_lane_s32(a, b, v, 0);
    vqrdmlahq_lane_s32(a, b, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vqrdmlah_laneq(int32x2_t a, int32x2_t b, int32x4_t v) {
    vqrdmlah_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqrdmlah_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqrdmlah_laneq_s32(a, b, v, 0);
    vqrdmlah_laneq_s32(a, b, v, 3);
  }
  
  void test_vqrdmlahq_laneq(int32x4_t a, int32x4_t b, int32x4_t v) {
    vqrdmlahq_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqrdmlahq_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqrdmlahq_laneq_s32(a, b, v, 0);
    vqrdmlahq_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vqrdmlsh_lane(int32x2_t a, int32x2_t b, int32x2_t v) {
    vqrdmlsh_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqrdmlsh_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqrdmlsh_lane_s32(a, b, v, 0);
    vqrdmlsh_lane_s32(a, b, v, 1);
  }
  
  void test_vqrdmlshq_lane(int32x4_t a, int32x4_t b, int32x2_t v) {
    vqrdmlshq_lane_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqrdmlshq_lane_s32(a, b, v, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqrdmlshq_lane_s32(a, b, v, 0);
    vqrdmlshq_lane_s32(a, b, v, 1);
  }
  
  #if defined(__aarch64__)
  void test_vqrdmlsh_laneq(int32x2_t a, int32x2_t b, int32x4_t v) {
    vqrdmlsh_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqrdmlsh_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqrdmlsh_laneq_s32(a, b, v, 0);
    vqrdmlsh_laneq_s32(a, b, v, 3);
  }
  
  void test_vqrdmlshq_laneq(int32x4_t a, int32x4_t b, int32x4_t v) {
    vqrdmlshq_laneq_s32(a, b, v, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqrdmlshq_laneq_s32(a, b, v, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqrdmlshq_laneq_s32(a, b, v, 0);
    vqrdmlshq_laneq_s32(a, b, v, 3);
  }
  #endif
  
  void test_vqrdmulh_lane(int32x2_t a, int32x2_t v) {
    vqrdmulh_lane_s32(a, v,  -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqrdmulh_lane_s32(a, v,  2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqrdmulh_lane_s32(a, v,  0);
    vqrdmulh_lane_s32(a, v,  1);
  }
  
  void test_vqrdmulhq_lane(int32x4_t a, int32x2_t v) {
    vqrdmulhq_lane_s32(a, v,  -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
    vqrdmulhq_lane_s32(a, v,  2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
    vqrdmulhq_lane_s32(a, v,  0);
    vqrdmulhq_lane_s32(a, v,  1);
  }
  
  #if defined(__aarch64__)
  void test_vqrdmulh_laneq(int32x2_t a, int32x4_t v) {
    vqrdmulh_laneq_s32(a, v,  -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqrdmulh_laneq_s32(a, v,  4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqrdmulh_laneq_s32(a, v,  0);
    vqrdmulh_laneq_s32(a, v,  3);
  }
  
  void test_vqrdmulhq_laneq(int32x4_t a, int32x4_t v) {
    vqrdmulhq_laneq_s32(a, v,  -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
    vqrdmulhq_laneq_s32(a, v,  4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
    vqrdmulhq_laneq_s32(a, v,  0);
    vqrdmulhq_laneq_s32(a, v,  3);
  }
  #endif
  