llvm-project/clang/test/CodeGen/aarch64-neon-intrinsics.c

// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +neon \
// RUN:   -ffp-contract=fast -S -O3 -o - %s | FileCheck %s

// Test new aarch64 intrinsics and types

#include <arm_neon.h>

int8x8_t test_vadd_s8(int8x8_t v1, int8x8_t v2) {
   // CHECK: test_vadd_s8
  return vadd_s8(v1, v2);
  // CHECK: add {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vadd_s16(int16x4_t v1, int16x4_t v2) {
   // CHECK: test_vadd_s16
  return vadd_s16(v1, v2);
  // CHECK: add {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vadd_s32(int32x2_t v1, int32x2_t v2) {
   // CHECK: test_vadd_s32
  return vadd_s32(v1, v2);
  // CHECK: add {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int64x1_t test_vadd_s64(int64x1_t v1, int64x1_t v2) {
  // CHECK: test_vadd_s64
  return vadd_s64(v1, v2);
  // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

float32x2_t test_vadd_f32(float32x2_t v1, float32x2_t v2) {
   // CHECK: test_vadd_f32
  return vadd_f32(v1, v2);
  // CHECK: fadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vadd_u8(uint8x8_t v1, uint8x8_t v2) {
   // CHECK: test_vadd_u8
  return vadd_u8(v1, v2);
  // CHECK: add {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vadd_u16(uint16x4_t v1, uint16x4_t v2) {
   // CHECK: test_vadd_u16
  return vadd_u16(v1, v2);
  // CHECK: add {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vadd_u32(uint32x2_t v1, uint32x2_t v2) {
   // CHECK: test_vadd_u32
  return vadd_u32(v1, v2);
  // CHECK: add {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint64x1_t test_vadd_u64(uint64x1_t v1, uint64x1_t v2) {
   // CHECK: test_vadd_u64
  return vadd_u64(v1, v2);
  // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8x16_t test_vaddq_s8(int8x16_t v1, int8x16_t v2) {
   // CHECK: test_vaddq_s8
  return vaddq_s8(v1, v2);
  // CHECK: add {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vaddq_s16(int16x8_t v1, int16x8_t v2) {
   // CHECK: test_vaddq_s16
  return vaddq_s16(v1, v2);
  // CHECK: add {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vaddq_s32(int32x4_t v1,int32x4_t  v2) {
   // CHECK: test_vaddq_s32
  return vaddq_s32(v1, v2);
  // CHECK: add {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int64x2_t test_vaddq_s64(int64x2_t v1, int64x2_t v2) {
   // CHECK: test_vaddq_s64
  return vaddq_s64(v1, v2);
  // CHECK: add {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

float32x4_t test_vaddq_f32(float32x4_t v1, float32x4_t v2) {
   // CHECK: test_vaddq_f32
  return vaddq_f32(v1, v2);
  // CHECK: fadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vaddq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vaddq_f64
  return vaddq_f64(v1, v2);
  // CHECK: fadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint8x16_t test_vaddq_u8(uint8x16_t v1, uint8x16_t v2) {
   // CHECK: test_vaddq_u8
  return vaddq_u8(v1, v2);
  // CHECK: add {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vaddq_u16(uint16x8_t v1, uint16x8_t v2) {
   // CHECK: test_vaddq_u16
  return vaddq_u16(v1, v2);
  // CHECK: add {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vaddq_u32(uint32x4_t v1, uint32x4_t v2) {
   // CHECK: vaddq_u32
  return vaddq_u32(v1, v2);
  // CHECK: add {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vaddq_u64(uint64x2_t v1, uint64x2_t v2) {
   // CHECK: test_vaddq_u64
  return vaddq_u64(v1, v2);
  // CHECK: add {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vsub_s8(int8x8_t v1, int8x8_t v2) {
   // CHECK: test_vsub_s8
  return vsub_s8(v1, v2);
  // CHECK: sub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}
int16x4_t test_vsub_s16(int16x4_t v1, int16x4_t v2) {
   // CHECK: test_vsub_s16
  return vsub_s16(v1, v2);
  // CHECK: sub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}
int32x2_t test_vsub_s32(int32x2_t v1, int32x2_t v2) {
   // CHECK: test_vsub_s32
  return vsub_s32(v1, v2);
  // CHECK: sub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int64x1_t test_vsub_s64(int64x1_t v1, int64x1_t v2) {
   // CHECK: test_vsub_s64
  return vsub_s64(v1, v2);
  // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

float32x2_t test_vsub_f32(float32x2_t v1, float32x2_t v2) {
   // CHECK: test_vsub_f32
  return vsub_f32(v1, v2);
  // CHECK: fsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vsub_u8(uint8x8_t v1, uint8x8_t v2) {
   // CHECK: test_vsub_u8
  return vsub_u8(v1, v2);
  // CHECK: sub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vsub_u16(uint16x4_t v1, uint16x4_t v2) {
   // CHECK: test_vsub_u16
  return vsub_u16(v1, v2);
  // CHECK: sub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vsub_u32(uint32x2_t v1, uint32x2_t v2) {
   // CHECK: test_vsub_u32
  return vsub_u32(v1, v2);
  // CHECK: sub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint64x1_t test_vsub_u64(uint64x1_t v1, uint64x1_t v2) {
   // CHECK: test_vsub_u64
  return vsub_u64(v1, v2);
  // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8x16_t test_vsubq_s8(int8x16_t v1, int8x16_t v2) {
   // CHECK: test_vsubq_s8
  return vsubq_s8(v1, v2);
  // CHECK: sub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vsubq_s16(int16x8_t v1, int16x8_t v2) {
   // CHECK: test_vsubq_s16
  return vsubq_s16(v1, v2);
  // CHECK: sub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vsubq_s32(int32x4_t v1,int32x4_t  v2) {
   // CHECK: test_vsubq_s32
  return vsubq_s32(v1, v2);
  // CHECK: sub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int64x2_t test_vsubq_s64(int64x2_t v1, int64x2_t v2) {
   // CHECK: test_vsubq_s64
  return vsubq_s64(v1, v2);
  // CHECK: sub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

float32x4_t test_vsubq_f32(float32x4_t v1, float32x4_t v2) {
   // CHECK: test_vsubq_f32
  return vsubq_f32(v1, v2);
  // CHECK: fsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vsubq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vsubq_f64
  return vsubq_f64(v1, v2);
  // CHECK: fsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint8x16_t test_vsubq_u8(uint8x16_t v1, uint8x16_t v2) {
   // CHECK: test_vsubq_u8
  return vsubq_u8(v1, v2);
  // CHECK: sub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vsubq_u16(uint16x8_t v1, uint16x8_t v2) {
   // CHECK: test_vsubq_u16
  return vsubq_u16(v1, v2);
  // CHECK: sub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vsubq_u32(uint32x4_t v1, uint32x4_t v2) {
   // CHECK: vsubq_u32
  return vsubq_u32(v1, v2);
  // CHECK: sub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vsubq_u64(uint64x2_t v1, uint64x2_t v2) {
   // CHECK: test_vsubq_u64
  return vsubq_u64(v1, v2);
  // CHECK: sub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vmul_s8(int8x8_t v1, int8x8_t v2) {
  // CHECK: test_vmul_s8
  return vmul_s8(v1, v2);
  // CHECK: mul {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vmul_s16(int16x4_t v1, int16x4_t v2) {
  // CHECK: test_vmul_s16
  return vmul_s16(v1, v2);
  // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vmul_s32(int32x2_t v1, int32x2_t v2) {
  // CHECK: test_vmul_s32
  return vmul_s32(v1, v2);
  // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vmul_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vmul_f32
  return vmul_f32(v1, v2);
  // CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}


uint8x8_t test_vmul_u8(uint8x8_t v1, uint8x8_t v2) {
  // CHECK: test_vmul_u8
  return vmul_u8(v1, v2);
  // CHECK: mul {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vmul_u16(uint16x4_t v1, uint16x4_t v2) {
  // CHECK: test_vmul_u16
  return vmul_u16(v1, v2);
  // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vmul_u32(uint32x2_t v1, uint32x2_t v2) {
  // CHECK: test_vmul_u32
  return vmul_u32(v1, v2);
  // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vmulq_s8(int8x16_t v1, int8x16_t v2) {
  // CHECK: test_vmulq_s8
  return vmulq_s8(v1, v2);
  // CHECK: mul {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vmulq_s16(int16x8_t v1, int16x8_t v2) {
  // CHECK: test_vmulq_s16
  return vmulq_s16(v1, v2);
  // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vmulq_s32(int32x4_t v1, int32x4_t v2) {
  // CHECK: test_vmulq_s32
  return vmulq_s32(v1, v2);
  // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}
    
uint8x16_t test_vmulq_u8(uint8x16_t v1, uint8x16_t v2) {
  // CHECK: test_vmulq_u8
  return vmulq_u8(v1, v2);
  // CHECK: mul {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vmulq_u16(uint16x8_t v1, uint16x8_t v2) {
  // CHECK: test_vmulq_u16
  return vmulq_u16(v1, v2);
  // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vmulq_u32(uint32x4_t v1, uint32x4_t v2) {
  // CHECK: test_vmulq_u32
  return vmulq_u32(v1, v2);
  // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x4_t test_vmulq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vmulq_f32
  return vmulq_f32(v1, v2);
  // CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vmulq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vmulq_f64
  return vmulq_f64(v1, v2);
  // CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

poly8x8_t test_vmul_p8(poly8x8_t v1, poly8x8_t v2) {
  //  test_vmul_p8
  return vmul_p8(v1, v2);
  //  pmul {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

poly8x16_t test_vmulq_p8(poly8x16_t v1, poly8x16_t v2) {
  // test_vmulq_p8
  return vmulq_p8(v1, v2);
  // pmul {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}


int8x8_t test_vmla_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) {
  // CHECK: test_vmla_s8
  return vmla_s8(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int8x8_t test_vmla_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) {
  // CHECK: test_vmla_s16
  return vmla_s16(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vmla_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) {
  // CHECK: test_vmla_s32
  return vmla_s32(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vmla_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
  // CHECK: test_vmla_f32
  return vmla_f32(v1, v2, v3);
  // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vmla_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) {
  // CHECK: test_vmla_u8
  return vmla_u8(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vmla_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) {
  // CHECK: test_vmla_u16
  return vmla_u16(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vmla_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) {
  // CHECK: test_vmla_u32
  return vmla_u32(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vmlaq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) {
  // CHECK: test_vmlaq_s8
  return vmlaq_s8(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vmlaq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) {
  // CHECK: test_vmlaq_s16
  return vmlaq_s16(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vmlaq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) {
  // CHECK: test_vmlaq_s32
  return vmlaq_s32(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
} 

float32x4_t test_vmlaq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) {
  // CHECK: test_vmlaq_f32
  return vmlaq_f32(v1, v2, v3);
  // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vmlaq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) {
   // CHECK: test_vmlaq_u8
  return vmlaq_u8(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vmlaq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) {
  // CHECK: test_vmlaq_u16
  return vmlaq_u16(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vmlaq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) {
  // CHECK: test_vmlaq_u32
  return vmlaq_u32(v1, v2, v3);
  // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vmlaq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) {
  // CHECK: test_vmlaq_f64
  return vmlaq_f64(v1, v2, v3);
  // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vmls_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) {
  // CHECK: test_vmls_s8
  return vmls_s8(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int8x8_t test_vmls_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) {
  // CHECK: test_vmls_s16
  return vmls_s16(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vmls_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) {
  // CHECK: test_vmls_s32
  return vmls_s32(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vmls_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
  // CHECK: test_vmls_f32
  return vmls_f32(v1, v2, v3);
  // CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vmls_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) {
  // CHECK: test_vmls_u8
  return vmls_u8(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vmls_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) {
  // CHECK: test_vmls_u16
  return vmls_u16(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vmls_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) {
  // CHECK: test_vmls_u32
  return vmls_u32(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}
int8x16_t test_vmlsq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) {
  // CHECK: test_vmlsq_s8
  return vmlsq_s8(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vmlsq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) {
  // CHECK: test_vmlsq_s16
  return vmlsq_s16(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vmlsq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) {
  // CHECK: test_vmlsq_s32
  return vmlsq_s32(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x4_t test_vmlsq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) {
  // CHECK: test_vmlsq_f32
  return vmlsq_f32(v1, v2, v3);
  // CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}
uint8x16_t test_vmlsq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) {
  // CHECK: test_vmlsq_u8
  return vmlsq_u8(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vmlsq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) {
  // CHECK: test_vmlsq_u16
  return vmlsq_u16(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vmlsq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) {
  // CHECK: test_vmlsq_u32
  return vmlsq_u32(v1, v2, v3);
  // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vmlsq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) {
  // CHECK: test_vmlsq_f64
  return vmlsq_f64(v1, v2, v3);
  // CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}
float32x2_t test_vfma_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
  // CHECK: test_vfma_f32
  return vfma_f32(v1, v2, v3);
  // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x4_t test_vfmaq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) {
  // CHECK: test_vfmaq_f32
  return vfmaq_f32(v1, v2, v3);
  // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vfmaq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) {
  // CHECK: test_vfmaq_f64
  return vfmaq_f64(v1, v2, v3);
  // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}
float32x2_t test_vfms_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
  // CHECK: test_vfms_f32
  return vfms_f32(v1, v2, v3);
  // CHECK: fmls v0.2s, v1.2s, v2.2s
}

float32x4_t test_vfmsq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) {
  // CHECK: test_vfmsq_f32
  return vfmsq_f32(v1, v2, v3);
  // CHECK: fmls v0.4s, v1.4s, v2.4s
}

float64x2_t test_vfmsq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) {
  // CHECK: vfmsq_f64
  return vfmsq_f64(v1, v2, v3);
  // CHECK: fmls v0.2d, v1.2d, v2.2d
}

float64x2_t test_vdivq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vdivq_f64
  return vdivq_f64(v1, v2);
  // CHECK: fdiv {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

float32x4_t test_vdivq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vdivq_f32
  return vdivq_f32(v1, v2);
  // CHECK: fdiv {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x2_t test_vdiv_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vdiv_f32
  return vdiv_f32(v1, v2);
  // CHECK: fdiv {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x8_t test_vaba_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) {
  // CHECK: test_vaba_s8
  return vaba_s8(v1, v2, v3);
  // CHECK: saba {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vaba_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) {
  // CHECK: test_vaba_s16
  return vaba_s16(v1, v2, v3);
  // CHECK: saba {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vaba_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) {
  // CHECK: test_vaba_s32
  return vaba_s32(v1, v2, v3);
  // CHECK: saba {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vaba_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) {
  // CHECK: test_vaba_u8
  return vaba_u8(v1, v2, v3);
  // CHECK: uaba {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vaba_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) {
  // CHECK: test_vaba_u16
  return vaba_u16(v1, v2, v3);
  // CHECK: uaba {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vaba_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) {
  // CHECK: test_vaba_u32
  return vaba_u32(v1, v2, v3);
  // CHECK: uaba {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vabaq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) {
  // CHECK: test_vabaq_s8
  return vabaq_s8(v1, v2, v3);
  // CHECK: saba {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vabaq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) {
  // CHECK: test_vabaq_s16
  return vabaq_s16(v1, v2, v3);
  // CHECK: saba {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vabaq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) {
  // CHECK: test_vabaq_s32
  return vabaq_s32(v1, v2, v3);
  // CHECK: saba {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vabaq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) {
  // CHECK: test_vabaq_u8
  return vabaq_u8(v1, v2, v3);
  // CHECK: uaba {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vabaq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) {
  // CHECK: test_vabaq_u16
  return vabaq_u16(v1, v2, v3);
  // CHECK: uaba {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vabaq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) {
  // CHECK: test_vabaq_u32
  return vabaq_u32(v1, v2, v3);
  // CHECK: uaba {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int8x8_t test_vabd_s8(int8x8_t v1, int8x8_t v2) {
  // CHECK: test_vabd_s8
  return vabd_s8(v1, v2);
  // CHECK: sabd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vabd_s16(int16x4_t v1, int16x4_t v2) {
  // CHECK: test_vabd_s16
  return vabd_s16(v1, v2);
  // CHECK: sabd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vabd_s32(int32x2_t v1, int32x2_t v2) {
  // CHECK: test_vabd_s32
  return vabd_s32(v1, v2);
  // CHECK: sabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vabd_u8(uint8x8_t v1, uint8x8_t v2) {
  // CHECK: test_vabd_u8
  return vabd_u8(v1, v2);
  // CHECK: uabd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vabd_u16(uint16x4_t v1, uint16x4_t v2) {
  // CHECK: test_vabd_u16
  return vabd_u16(v1, v2);
  // CHECK: uabd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vabd_u32(uint32x2_t v1, uint32x2_t v2) {
  // CHECK: test_vabd_u32
  return vabd_u32(v1, v2);
  // CHECK: uabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vabd_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vabd_f32
  return vabd_f32(v1, v2);
  // CHECK: fabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vabdq_s8(int8x16_t v1, int8x16_t v2) {
  // CHECK: test_vabdq_s8
  return vabdq_s8(v1, v2);
  // CHECK: sabd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vabdq_s16(int16x8_t v1, int16x8_t v2) {
  // CHECK: test_vabdq_s16
  return vabdq_s16(v1, v2);
  // CHECK: sabd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vabdq_s32(int32x4_t v1, int32x4_t v2) {
  // CHECK: test_vabdq_s32
  return vabdq_s32(v1, v2);
  // CHECK: sabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vabdq_u8(uint8x16_t v1, uint8x16_t v2) {
  // CHECK: test_vabdq_u8
  return vabdq_u8(v1, v2);
  // CHECK: uabd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vabdq_u16(uint16x8_t v1, uint16x8_t v2) {
  // CHECK: test_vabdq_u16
  return vabdq_u16(v1, v2);
  // CHECK: uabd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vabdq_u32(uint32x4_t v1, uint32x4_t v2) {
  // CHECK: test_vabdq_u32
  return vabdq_u32(v1, v2);
  // CHECK: uabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x4_t test_vabdq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vabdq_f32
  return vabdq_f32(v1, v2);
  // CHECK: fabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vabdq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vabdq_f64
  return vabdq_f64(v1, v2);
  // CHECK: fabd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}


int8x8_t test_vbsl_s8(uint8x8_t v1, int8x8_t v2, int8x8_t v3) {
  // CHECK: test_vbsl_s8
  return vbsl_s8(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int8x8_t test_vbsl_s16(uint16x4_t v1, int16x4_t v2, int16x4_t v3) {
  // CHECK: test_vbsl_s16
  return vbsl_s16(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int32x2_t test_vbsl_s32(uint32x2_t v1, int32x2_t v2, int32x2_t v3) {
  // CHECK: test_vbsl_s32
  return vbsl_s32(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint64x1_t test_vbsl_s64(uint64x1_t v1, uint64x1_t v2, uint64x1_t v3) {
  // CHECK: test_vbsl_s64
  return vbsl_s64(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint8x8_t test_vbsl_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) {
  // CHECK: test_vbsl_u8
  return vbsl_u8(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vbsl_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) {
  // CHECK: test_vbsl_u16
  return vbsl_u16(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint32x2_t test_vbsl_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) {
  // CHECK: test_vbsl_u32
  return vbsl_u32(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint64x1_t test_vbsl_u64(uint64x1_t v1, uint64x1_t v2, uint64x1_t v3) {
  // CHECK: test_vbsl_u64
  return vbsl_u64(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

float32x2_t test_vbsl_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
  // CHECK: test_vbsl_f32
  return vbsl_f32(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

poly8x8_t test_vbsl_p8(uint8x8_t v1, poly8x8_t v2, poly8x8_t v3) {
  // CHECK: test_vbsl_p8
  return vbsl_p8(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

poly16x4_t test_vbsl_p16(uint16x4_t v1, poly16x4_t v2, poly16x4_t v3) {
  // CHECK: test_vbsl_p16
  return vbsl_p16(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int8x16_t test_vbslq_s8(uint8x16_t v1, int8x16_t v2, int8x16_t v3) {
  // CHECK: test_vbslq_s8
  return vbslq_s8(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vbslq_s16(uint16x8_t v1, int16x8_t v2, int16x8_t v3) {
  // CHECK: test_vbslq_s16
  return vbslq_s16(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int32x4_t test_vbslq_s32(uint32x4_t v1, int32x4_t v2, int32x4_t v3) {
  // CHECK: test_vbslq_s32
  return vbslq_s32(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int64x2_t test_vbslq_s64(uint64x2_t v1, int64x2_t v2, int64x2_t v3) {
  // CHECK: test_vbslq_s64
  return vbslq_s64(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint8x16_t test_vbslq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) {
  // CHECK: test_vbslq_u8
  return vbslq_u8(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vbslq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) {
  // CHECK: test_vbslq_u16
  return vbslq_u16(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int32x4_t test_vbslq_u32(uint32x4_t v1, int32x4_t v2, int32x4_t v3) {
  // CHECK: test_vbslq_u32
  return vbslq_s32(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint64x2_t test_vbslq_u64(uint64x2_t v1, uint64x2_t v2, uint64x2_t v3) {
  // CHECK: test_vbslq_u64
  return vbslq_u64(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

float32x4_t test_vbslq_f32(uint32x4_t v1, float32x4_t v2, float32x4_t v3) {
  // CHECK: test_vbslq_f32
  return vbslq_f32(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

poly8x16_t test_vbslq_p8(uint8x16_t v1, poly8x16_t v2, poly8x16_t v3) {
  // CHECK: test_vbslq_p8
  return vbslq_p8(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

poly16x8_t test_vbslq_p16(uint16x8_t v1, poly16x8_t v2, poly16x8_t v3) {
  // CHECK: test_vbslq_p16
  return vbslq_p16(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

float64x2_t test_vbslq_f64(uint64x2_t v1, float64x2_t v2, float64x2_t v3) {
  // CHECK: test_vbslq_f64
  return vbslq_f64(v1, v2, v3);
  // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

float32x2_t test_vrecps_f32(float32x2_t v1, float32x2_t v2) {
   // CHECK: test_vrecps_f32
   return vrecps_f32(v1, v2);
   // CHECK: frecps {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x4_t test_vrecpsq_f32(float32x4_t v1, float32x4_t v2) {
   // CHECK: test_vrecpsq_f32
   return vrecpsq_f32(v1, v2);
   // CHECK: frecps {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vrecpsq_f64(float64x2_t v1, float64x2_t v2) {
   // CHECK: test_vrecpsq_f64
  return vrecpsq_f64(v1, v2);
  // CHECK: frecps {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

float32x2_t test_vrsqrts_f32(float32x2_t v1, float32x2_t v2) {
   // CHECK: test_vrsqrts_f32
  return vrsqrts_f32(v1, v2);
  // CHECK: frsqrts {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x4_t test_vrsqrtsq_f32(float32x4_t v1, float32x4_t v2) {
   // CHECK: test_vrsqrtsq_f32
  return vrsqrtsq_f32(v1, v2);
  // CHECK: frsqrts {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vrsqrtsq_f64(float64x2_t v1, float64x2_t v2) {
   // CHECK: test_vrsqrtsq_f64
  return vrsqrtsq_f64(v1, v2);
  // CHECK: frsqrts {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint32x2_t test_vcage_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vcage_f32
  return vcage_f32(v1, v2);
  // CHECK: facge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint32x4_t test_vcageq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vcageq_f32
  return vcageq_f32(v1, v2);
  // CHECK: facge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vcageq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vcageq_f64
  return vcageq_f64(v1, v2);
  // CHECK: facge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint32x2_t test_vcagt_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vcagt_f32
  return vcagt_f32(v1, v2);
  // CHECK: facgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint32x4_t test_vcagtq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vcagtq_f32
  return vcagtq_f32(v1, v2);
  // CHECK: facgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vcagtq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vcagtq_f64
  return vcagtq_f64(v1, v2);
  // CHECK: facgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint32x2_t test_vcale_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vcale_f32
  return vcale_f32(v1, v2);
 // Using registers other than v0, v1 are possible, but would be odd.
  // CHECK: facge {{v[0-9]+}}.2s, v1.2s, v0.2s
}

uint32x4_t test_vcaleq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vcaleq_f32
  return vcaleq_f32(v1, v2);
  // Using registers other than v0, v1 are possible, but would be odd.
  // CHECK: facge {{v[0-9]+}}.4s, v1.4s, v0.4s
}

uint64x2_t test_vcaleq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vcaleq_f64
  return vcaleq_f64(v1, v2);
  // Using registers other than v0, v1 are possible, but would be odd.
  // CHECK: facge {{v[0-9]+}}.2d, v1.2d, v0.2d
}

uint32x2_t test_vcalt_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vcalt_f32
  return vcalt_f32(v1, v2);
  // Using registers other than v0, v1 are possible, but would be odd.
  // CHECK: facgt {{v[0-9]+}}.2s, v1.2s, v0.2s
}

uint32x4_t test_vcaltq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vcaltq_f32
  return vcaltq_f32(v1, v2);
  // Using registers other than v0, v1 are possible, but would be odd.
  // CHECK: facgt {{v[0-9]+}}.4s, v1.4s, v0.4s
}

uint64x2_t test_vcaltq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vcaltq_f64
  return vcaltq_f64(v1, v2);
  // Using registers other than v0, v1 are possible, but would be odd.
  // CHECK: facgt {{v[0-9]+}}.2d, v1.2d, v0.2d
}

uint8x8_t test_vtst_s8(int8x8_t v1, int8x8_t v2) {
   // CHECK: test_vtst_s8
  return vtst_s8(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vtst_s16(int16x4_t v1, int16x4_t v2) {
   // CHECK: test_vtst_s16
  return vtst_s16(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vtst_s32(int32x2_t v1, int32x2_t v2) {
   // CHECK: test_vtst_s32
  return vtst_s32(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vtst_u8(uint8x8_t v1, uint8x8_t v2) {
   // CHECK: test_vtst_u8
  return vtst_u8(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vtst_u16(uint16x4_t v1, uint16x4_t v2) {
   // CHECK: test_vtst_u16
  return vtst_u16(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vtst_u32(uint32x2_t v1, uint32x2_t v2) {
   // CHECK: test_vtst_u32
  return vtst_u32(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x16_t test_vtstq_s8(int8x16_t v1, int8x16_t v2) {
   // CHECK: test_vtstq_s8
  return vtstq_s8(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vtstq_s16(int16x8_t v1, int16x8_t v2) {
   // CHECK: test_vtstq_s16
  return vtstq_s16(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vtstq_s32(int32x4_t v1, int32x4_t v2) {
   // CHECK: test_vtstq_s32
  return vtstq_s32(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vtstq_u8(uint8x16_t v1, uint8x16_t v2) {
   // CHECK: test_vtstq_u8
  return vtstq_u8(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vtstq_u16(uint16x8_t v1, uint16x8_t v2) {
   // CHECK: test_vtstq_u16
  return vtstq_u16(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vtstq_u32(uint32x4_t v1, uint32x4_t v2) {
   // CHECK: test_vtstq_u32
  return vtstq_u32(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vtstq_s64(int64x2_t v1, int64x2_t v2) {
   // CHECK: test_vtstq_s64
  return vtstq_s64(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint64x2_t test_vtstq_u64(uint64x2_t v1, uint64x2_t v2) {
   // CHECK: test_vtstq_u64
  return vtstq_u64(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint8x8_t test_vtst_p8(poly8x8_t v1, poly8x8_t v2) {
   // CHECK: test_vtst_p8
  return vtst_p8(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vtst_p16(poly16x4_t v1, poly16x4_t v2) {
   // CHECK: test_vtst_p16
  return vtst_p16(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint8x16_t test_vtstq_p8(poly8x16_t v1, poly8x16_t v2) {
   // CHECK: test_vtstq_p8
  return vtstq_p8(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vtstq_p16(poly16x8_t v1, poly16x8_t v2) {
   // CHECK: test_vtstq_p16
  return vtstq_p16(v1, v2);
  // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}


uint8x8_t test_vceq_s8(int8x8_t v1, int8x8_t v2) {
  // CHECK: test_vceq_s8
  return vceq_s8(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vceq_s16(int16x4_t v1, int16x4_t v2) {
  // CHECK: test_vceq_s16
  return vceq_s16(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vceq_s32(int32x2_t v1, int32x2_t v2) {
  // CHECK: test_vceq_s32
  return vceq_s32(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint32x2_t test_vceq_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vceq_f32
  return vceq_f32(v1, v2);
  // CHECK: fcmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vceq_u8(uint8x8_t v1, uint8x8_t v2) {
  // CHECK: test_vceq_u8
  return vceq_u8(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vceq_u16(uint16x4_t v1, uint16x4_t v2) {
  // CHECK: test_vceq_u16
  return vceq_u16(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vceq_u32(uint32x2_t v1, uint32x2_t v2) {
  // CHECK: test_vceq_u32
  return vceq_u32(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vceq_p8(poly8x8_t v1, poly8x8_t v2) {
  // CHECK: test_vceq_p8
  return vceq_p8(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint8x16_t test_vceqq_s8(int8x16_t v1, int8x16_t v2) {
  // CHECK: test_vceqq_s8
  return vceqq_s8(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vceqq_s16(int16x8_t v1, int16x8_t v2) {
  // CHECK: test_vceqq_s16
  return vceqq_s16(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vceqq_s32(int32x4_t v1, int32x4_t v2) {
  // CHECK: test_vceqq_s32
  return vceqq_s32(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint32x4_t test_vceqq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vceqq_f32
  return vceqq_f32(v1, v2);
  // CHECK: fcmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vceqq_u8(uint8x16_t v1, uint8x16_t v2) {
  // CHECK: test_vceqq_u8
  return vceqq_u8(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vceqq_u16(uint16x8_t v1, uint16x8_t v2) {
  // CHECK: test_vceqq_u16
  return vceqq_u16(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vceqq_u32(uint32x4_t v1, uint32x4_t v2) {
  // CHECK: test_vceqq_u32
  return vceqq_u32(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vceqq_p8(poly8x16_t v1, poly8x16_t v2) {
  // CHECK: test_vceqq_p8
  return vceqq_p8(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}


uint64x2_t test_vceqq_s64(int64x2_t v1, int64x2_t v2) {
  // CHECK: test_vceqq_s64
  return vceqq_s64(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint64x2_t test_vceqq_u64(uint64x2_t v1, uint64x2_t v2) {
  // CHECK: test_vceqq_u64
  return vceqq_u64(v1, v2);
  // CHECK: cmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint64x2_t test_vceqq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vceqq_f64
  return vceqq_f64(v1, v2);
  // CHECK: fcmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}
uint8x8_t test_vcge_s8(int8x8_t v1, int8x8_t v2) {
// CHECK: test_vcge_s8
  return vcge_s8(v1, v2);
// CHECK: cmge {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vcge_s16(int16x4_t v1, int16x4_t v2) {
// CHECK: test_vcge_s16
  return vcge_s16(v1, v2);
// CHECK: cmge {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vcge_s32(int32x2_t v1, int32x2_t v2) {
// CHECK: test_vcge_s32
  return vcge_s32(v1, v2);
// CHECK: cmge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint32x2_t test_vcge_f32(float32x2_t v1, float32x2_t v2) {
// CHECK: test_vcge_f32
  return vcge_f32(v1, v2);
// CHECK: fcmge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vcge_u8(uint8x8_t v1, uint8x8_t v2) {
// CHECK: test_vcge_u8
  return vcge_u8(v1, v2);
// CHECK: cmhs {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vcge_u16(uint16x4_t v1, uint16x4_t v2) {
// CHECK: test_vcge_u16
  return vcge_u16(v1, v2);
// CHECK: cmhs {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vcge_u32(uint32x2_t v1, uint32x2_t v2) {
// CHECK: test_vcge_u32
  return vcge_u32(v1, v2);
// CHECK: cmhs {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x16_t test_vcgeq_s8(int8x16_t v1, int8x16_t v2) {
// CHECK: test_vcgeq_s8
  return vcgeq_s8(v1, v2);
// CHECK: cmge {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vcgeq_s16(int16x8_t v1, int16x8_t v2) {
// CHECK: test_vcgeq_s16
  return vcgeq_s16(v1, v2);
// CHECK: cmge {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vcgeq_s32(int32x4_t v1, int32x4_t v2) {
// CHECK: test_vcgeq_s32
  return vcgeq_s32(v1, v2);
// CHECK: cmge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint32x4_t test_vcgeq_f32(float32x4_t v1, float32x4_t v2) {
// CHECK: test_vcgeq_f32
  return vcgeq_f32(v1, v2);
// CHECK: fcmge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vcgeq_u8(uint8x16_t v1, uint8x16_t v2) {
// CHECK: test_vcgeq_u8
  return vcgeq_u8(v1, v2);
// CHECK: cmhs {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vcgeq_u16(uint16x8_t v1, uint16x8_t v2) {
// CHECK: test_vcgeq_u16
  return vcgeq_u16(v1, v2);
// CHECK: cmhs {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vcgeq_u32(uint32x4_t v1, uint32x4_t v2) {
// CHECK: test_vcgeq_u32
  return vcgeq_u32(v1, v2);
// CHECK: cmhs {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vcgeq_s64(int64x2_t v1, int64x2_t v2) {
// CHECK: test_vcgeq_s64
  return vcgeq_s64(v1, v2);
// CHECK: cmge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint64x2_t test_vcgeq_u64(uint64x2_t v1, uint64x2_t v2) {
// CHECK: test_vcgeq_u64
  return vcgeq_u64(v1, v2);
// CHECK: cmhs {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint64x2_t test_vcgeq_f64(float64x2_t v1, float64x2_t v2) {
// CHECK: test_vcgeq_f64
  return vcgeq_f64(v1, v2);
// CHECK: fcmge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

// Notes about vcle:
// LE condition predicate implemented as GE, so check reversed operands.
// Using registers other than v0, v1 are possible, but would be odd.
uint8x8_t test_vcle_s8(int8x8_t v1, int8x8_t v2) {
  // CHECK: test_vcle_s8
  return vcle_s8(v1, v2);
  // CHECK: cmge {{v[0-9]+}}.8b, v1.8b, v0.8b
}

uint16x4_t test_vcle_s16(int16x4_t v1, int16x4_t v2) {
  // CHECK: test_vcle_s16
  return vcle_s16(v1, v2);
  // CHECK: cmge {{v[0-9]+}}.4h, v1.4h, v0.4h
}

uint32x2_t test_vcle_s32(int32x2_t v1, int32x2_t v2) {
  // CHECK: test_vcle_s32
  return vcle_s32(v1, v2);
  // CHECK: cmge {{v[0-9]+}}.2s, v1.2s, v0.2s
}

uint32x2_t test_vcle_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vcle_f32
  return vcle_f32(v1, v2);
  // CHECK: fcmge {{v[0-9]+}}.2s, v1.2s, v0.2s
}

uint8x8_t test_vcle_u8(uint8x8_t v1, uint8x8_t v2) {
  // CHECK: test_vcle_u8
  return vcle_u8(v1, v2);
  // CHECK: cmhs {{v[0-9]+}}.8b, v1.8b, v0.8b
}

uint16x4_t test_vcle_u16(uint16x4_t v1, uint16x4_t v2) {
  // CHECK: test_vcle_u16
  return vcle_u16(v1, v2);
  // CHECK: cmhs {{v[0-9]+}}.4h, v1.4h, v0.4h
}

uint32x2_t test_vcle_u32(uint32x2_t v1, uint32x2_t v2) {
  // CHECK: test_vcle_u32
  return vcle_u32(v1, v2);
  // CHECK: cmhs {{v[0-9]+}}.2s, v1.2s, v0.2s
}

uint8x16_t test_vcleq_s8(int8x16_t v1, int8x16_t v2) {
  // CHECK: test_vcleq_s8
  return vcleq_s8(v1, v2);
  // CHECK: cmge {{v[0-9]+}}.16b, v1.16b, v0.16b
}

uint16x8_t test_vcleq_s16(int16x8_t v1, int16x8_t v2) {
  // CHECK: test_vcleq_s16
  return vcleq_s16(v1, v2);
  // CHECK: cmge {{v[0-9]+}}.8h, v1.8h, v0.8h
}

uint32x4_t test_vcleq_s32(int32x4_t v1, int32x4_t v2) {
  // CHECK: test_vcleq_s32
  return vcleq_s32(v1, v2);
  // CHECK: cmge {{v[0-9]+}}.4s, v1.4s, v0.4s
}

uint32x4_t test_vcleq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vcleq_f32
  return vcleq_f32(v1, v2);
  // CHECK: fcmge {{v[0-9]+}}.4s, v1.4s, v0.4s
}

uint8x16_t test_vcleq_u8(uint8x16_t v1, uint8x16_t v2) {
  // CHECK: test_vcleq_u8
  return vcleq_u8(v1, v2);
  // CHECK: cmhs {{v[0-9]+}}.16b, v1.16b, v0.16b
}

uint16x8_t test_vcleq_u16(uint16x8_t v1, uint16x8_t v2) {
  // CHECK: test_vcleq_u16
  return vcleq_u16(v1, v2);
  // CHECK: cmhs {{v[0-9]+}}.8h, v1.8h, v0.8h
}

uint32x4_t test_vcleq_u32(uint32x4_t v1, uint32x4_t v2) {
  // CHECK: test_vcleq_u32
  return vcleq_u32(v1, v2);
  // CHECK: cmhs {{v[0-9]+}}.4s, v1.4s, v0.4s
}

uint64x2_t test_vcleq_s64(int64x2_t v1, int64x2_t v2) {
  // CHECK: test_vcleq_s64
  return vcleq_s64(v1, v2);
  // CHECK: cmge {{v[0-9]+}}.2d, v1.2d, v0.2d
}

uint64x2_t test_vcleq_u64(uint64x2_t v1, uint64x2_t v2) {
  // CHECK: test_vcleq_u64
  return vcleq_u64(v1, v2);
  // CHECK: cmhs {{v[0-9]+}}.2d, v1.2d, v0.2d
}

uint64x2_t test_vcleq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vcleq_f64
  return vcleq_f64(v1, v2);
  // CHECK: fcmge {{v[0-9]+}}.2d, v1.2d, v0.2d
}


uint8x8_t test_vcgt_s8(int8x8_t v1, int8x8_t v2) {
  // CHECK: test_vcgt_s8
  return vcgt_s8(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vcgt_s16(int16x4_t v1, int16x4_t v2) {
  // CHECK: test_vcgt_s16
  return vcgt_s16(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vcgt_s32(int32x2_t v1, int32x2_t v2) {
  // CHECK: test_vcgt_s32
  return vcgt_s32(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint32x2_t test_vcgt_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vcgt_f32
  return vcgt_f32(v1, v2);
  // CHECK: fcmgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vcgt_u8(uint8x8_t v1, uint8x8_t v2) {
  // CHECK: test_vcgt_u8
  return vcgt_u8(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vcgt_u16(uint16x4_t v1, uint16x4_t v2) {
  // CHECK: test_vcgt_u16
  return vcgt_u16(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vcgt_u32(uint32x2_t v1, uint32x2_t v2) {
  // CHECK: test_vcgt_u32
  return vcgt_u32(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x16_t test_vcgtq_s8(int8x16_t v1, int8x16_t v2) {
  // CHECK: test_vcgtq_s8
  return vcgtq_s8(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vcgtq_s16(int16x8_t v1, int16x8_t v2) {
  // CHECK: test_vcgtq_s16
  return vcgtq_s16(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vcgtq_s32(int32x4_t v1, int32x4_t v2) {
  // CHECK: test_vcgtq_s32
  return vcgtq_s32(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint32x4_t test_vcgtq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vcgtq_f32
  return vcgtq_f32(v1, v2);
  // CHECK: fcmgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vcgtq_u8(uint8x16_t v1, uint8x16_t v2) {
  // CHECK: test_vcgtq_u8
  return vcgtq_u8(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vcgtq_u16(uint16x8_t v1, uint16x8_t v2) {
  // CHECK: test_vcgtq_u16
  return vcgtq_u16(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vcgtq_u32(uint32x4_t v1, uint32x4_t v2) {
  // CHECK: test_vcgtq_u32
  return vcgtq_u32(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vcgtq_s64(int64x2_t v1, int64x2_t v2) {
  // CHECK: test_vcgtq_s64
  return vcgtq_s64(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint64x2_t test_vcgtq_u64(uint64x2_t v1, uint64x2_t v2) {
  // CHECK: test_vcgtq_u64
  return vcgtq_u64(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint64x2_t test_vcgtq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vcgtq_f64
  return vcgtq_f64(v1, v2);
  // CHECK: fcmgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}


// Notes about vclt:
// LT condition predicate implemented as GT, so check reversed operands.
// Using registers other than v0, v1 are possible, but would be odd.

uint8x8_t test_vclt_s8(int8x8_t v1, int8x8_t v2) {
  // CHECK: test_vclt_s8
  return vclt_s8(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.8b, v1.8b, v0.8b
}

uint16x4_t test_vclt_s16(int16x4_t v1, int16x4_t v2) {
  // CHECK: test_vclt_s16
  return vclt_s16(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.4h, v1.4h, v0.4h
}

uint32x2_t test_vclt_s32(int32x2_t v1, int32x2_t v2) {
  // CHECK: test_vclt_s32
  return vclt_s32(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.2s, v1.2s, v0.2s
}

uint32x2_t test_vclt_f32(float32x2_t v1, float32x2_t v2) {
  // CHECK: test_vclt_f32
  return vclt_f32(v1, v2);
  // CHECK: fcmgt {{v[0-9]+}}.2s, v1.2s, v0.2s
}

uint8x8_t test_vclt_u8(uint8x8_t v1, uint8x8_t v2) {
  // CHECK: test_vclt_u8
  return vclt_u8(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.8b, v1.8b, v0.8b
}

uint16x4_t test_vclt_u16(uint16x4_t v1, uint16x4_t v2) {
  // CHECK: test_vclt_u16
  return vclt_u16(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.4h, v1.4h, v0.4h
}

uint32x2_t test_vclt_u32(uint32x2_t v1, uint32x2_t v2) {
  // CHECK: test_vclt_u32
  return vclt_u32(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.2s, v1.2s, v0.2s
}

uint8x16_t test_vcltq_s8(int8x16_t v1, int8x16_t v2) {
  // CHECK: test_vcltq_s8
  return vcltq_s8(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.16b, v1.16b, v0.16b
}

uint16x8_t test_vcltq_s16(int16x8_t v1, int16x8_t v2) {
  // CHECK: test_vcltq_s16
  return vcltq_s16(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.8h, v1.8h, v0.8h
}

uint32x4_t test_vcltq_s32(int32x4_t v1, int32x4_t v2) {
  // CHECK: test_vcltq_s32
  return vcltq_s32(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.4s, v1.4s, v0.4s
}

uint32x4_t test_vcltq_f32(float32x4_t v1, float32x4_t v2) {
  // CHECK: test_vcltq_f32
  return vcltq_f32(v1, v2);
  // CHECK: fcmgt {{v[0-9]+}}.4s, v1.4s, v0.4s
}

uint8x16_t test_vcltq_u8(uint8x16_t v1, uint8x16_t v2) {
  // CHECK: test_vcltq_u8
  return vcltq_u8(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.16b, v1.16b, v0.16b
}

uint16x8_t test_vcltq_u16(uint16x8_t v1, uint16x8_t v2) {
  // CHECK: test_vcltq_u16
  return vcltq_u16(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.8h, v1.8h, v0.8h
}

uint32x4_t test_vcltq_u32(uint32x4_t v1, uint32x4_t v2) {
  // CHECK: test_vcltq_u32
  return vcltq_u32(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.4s, v1.4s, v0.4s
}

uint64x2_t test_vcltq_s64(int64x2_t v1, int64x2_t v2) {
  // CHECK: test_vcltq_s64
  return vcltq_s64(v1, v2);
  // CHECK: cmgt {{v[0-9]+}}.2d, v1.2d, v0.2d
}

uint64x2_t test_vcltq_u64(uint64x2_t v1, uint64x2_t v2) {
  // CHECK: test_vcltq_u64
  return vcltq_u64(v1, v2);
  // CHECK: cmhi {{v[0-9]+}}.2d, v1.2d, v0.2d
}

uint64x2_t test_vcltq_f64(float64x2_t v1, float64x2_t v2) {
  // CHECK: test_vcltq_f64
  return vcltq_f64(v1, v2);
  // CHECK: fcmgt {{v[0-9]+}}.2d, v1.2d, v0.2d
}


int8x8_t test_vhadd_s8(int8x8_t v1, int8x8_t v2) {
// CHECK: test_vhadd_s8
  return vhadd_s8(v1, v2);
  // CHECK: shadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vhadd_s16(int16x4_t v1, int16x4_t v2) {
// CHECK: test_vhadd_s16
  return vhadd_s16(v1, v2);
  // CHECK: shadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vhadd_s32(int32x2_t v1, int32x2_t v2) {
// CHECK: test_vhadd_s32
  return vhadd_s32(v1, v2);
  // CHECK: shadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vhadd_u8(uint8x8_t v1, uint8x8_t v2) {
// CHECK: test_vhadd_u8
  return vhadd_u8(v1, v2);
  // CHECK: uhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vhadd_u16(uint16x4_t v1, uint16x4_t v2) {
// CHECK: test_vhadd_u16
  return vhadd_u16(v1, v2);
  // CHECK: uhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vhadd_u32(uint32x2_t v1, uint32x2_t v2) {
// CHECK: test_vhadd_u32
  return vhadd_u32(v1, v2);
  // CHECK: uhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vhaddq_s8(int8x16_t v1, int8x16_t v2) {
// CHECK: test_vhaddq_s8
  return vhaddq_s8(v1, v2);
  // CHECK: shadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vhaddq_s16(int16x8_t v1, int16x8_t v2) {
// CHECK: test_vhaddq_s16
  return vhaddq_s16(v1, v2);
  // CHECK: shadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vhaddq_s32(int32x4_t v1, int32x4_t v2) {
// CHECK: test_vhaddq_s32
  return vhaddq_s32(v1, v2);
  // CHECK: shadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vhaddq_u8(uint8x16_t v1, uint8x16_t v2) {
// CHECK: test_vhaddq_u8
  return vhaddq_u8(v1, v2);
  // CHECK: uhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vhaddq_u16(uint16x8_t v1, uint16x8_t v2) {
// CHECK: test_vhaddq_u16
  return vhaddq_u16(v1, v2);
  // CHECK: uhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vhaddq_u32(uint32x4_t v1, uint32x4_t v2) {
// CHECK: test_vhaddq_u32
  return vhaddq_u32(v1, v2);
  // CHECK: uhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}


int8x8_t test_vhsub_s8(int8x8_t v1, int8x8_t v2) {
// CHECK: test_vhsub_s8
  return vhsub_s8(v1, v2);
  // CHECK: shsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vhsub_s16(int16x4_t v1, int16x4_t v2) {
// CHECK: test_vhsub_s16
  return vhsub_s16(v1, v2);
  // CHECK: shsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vhsub_s32(int32x2_t v1, int32x2_t v2) {
// CHECK: test_vhsub_s32
  return vhsub_s32(v1, v2);
  // CHECK: shsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vhsub_u8(uint8x8_t v1, uint8x8_t v2) {
// CHECK: test_vhsub_u8
  return vhsub_u8(v1, v2);
  // CHECK: uhsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vhsub_u16(uint16x4_t v1, uint16x4_t v2) {
// CHECK: test_vhsub_u16
  return vhsub_u16(v1, v2);
  // CHECK: uhsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vhsub_u32(uint32x2_t v1, uint32x2_t v2) {
// CHECK: test_vhsub_u32
  return vhsub_u32(v1, v2);
  // CHECK: uhsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vhsubq_s8(int8x16_t v1, int8x16_t v2) {
// CHECK: test_vhsubq_s8
  return vhsubq_s8(v1, v2);
  // CHECK: shsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vhsubq_s16(int16x8_t v1, int16x8_t v2) {
// CHECK: test_vhsubq_s16
  return vhsubq_s16(v1, v2);
  // CHECK: shsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vhsubq_s32(int32x4_t v1, int32x4_t v2) {
// CHECK: test_vhsubq_s32
  return vhsubq_s32(v1, v2);
  // CHECK: shsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vhsubq_u8(uint8x16_t v1, uint8x16_t v2) {
// CHECK: test_vhsubq_u8
  return vhsubq_u8(v1, v2);
  // CHECK: uhsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vhsubq_u16(uint16x8_t v1, uint16x8_t v2) {
// CHECK: test_vhsubq_u16
  return vhsubq_u16(v1, v2);
  // CHECK: uhsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vhsubq_u32(uint32x4_t v1, uint32x4_t v2) {
// CHECK: test_vhsubq_u32
  return vhsubq_u32(v1, v2);
  // CHECK: uhsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}


int8x8_t test_vrhadd_s8(int8x8_t v1, int8x8_t v2) {
// CHECK: test_vrhadd_s8
  return vrhadd_s8(v1, v2);
// CHECK: srhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vrhadd_s16(int16x4_t v1, int16x4_t v2) {
// CHECK: test_vrhadd_s16
  return vrhadd_s16(v1, v2);
// CHECK: srhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vrhadd_s32(int32x2_t v1, int32x2_t v2) {
// CHECK: test_vrhadd_s32
  return vrhadd_s32(v1, v2);
// CHECK: srhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vrhadd_u8(uint8x8_t v1, uint8x8_t v2) {
// CHECK: test_vrhadd_u8
  return vrhadd_u8(v1, v2);
// CHECK: urhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vrhadd_u16(uint16x4_t v1, uint16x4_t v2) {
// CHECK: test_vrhadd_u16
  return vrhadd_u16(v1, v2);
// CHECK: urhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vrhadd_u32(uint32x2_t v1, uint32x2_t v2) {
// CHECK: test_vrhadd_u32
  return vrhadd_u32(v1, v2);
// CHECK: urhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vrhaddq_s8(int8x16_t v1, int8x16_t v2) {
// CHECK: test_vrhaddq_s8
  return vrhaddq_s8(v1, v2);
// CHECK: srhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vrhaddq_s16(int16x8_t v1, int16x8_t v2) {
// CHECK: test_vrhaddq_s16
  return vrhaddq_s16(v1, v2);
// CHECK: srhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vrhaddq_s32(int32x4_t v1, int32x4_t v2) {
// CHECK: test_vrhaddq_s32
  return vrhaddq_s32(v1, v2);
// CHECK: srhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vrhaddq_u8(uint8x16_t v1, uint8x16_t v2) {
// CHECK: test_vrhaddq_u8
  return vrhaddq_u8(v1, v2);
// CHECK: urhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vrhaddq_u16(uint16x8_t v1, uint16x8_t v2) {
// CHECK: test_vrhaddq_u16
  return vrhaddq_u16(v1, v2);
// CHECK: urhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vrhaddq_u32(uint32x4_t v1, uint32x4_t v2) {
// CHECK: test_vrhaddq_u32
  return vrhaddq_u32(v1, v2);
// CHECK: urhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}
int8x8_t test_vqadd_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vqadd_s8
  return vqadd_s8(a, b);
  // CHECK: sqadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vqadd_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vqadd_s16
  return vqadd_s16(a, b);
  // CHECK: sqadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vqadd_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vqadd_s32
  return vqadd_s32(a, b);
  // CHECK: sqadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int64x1_t test_vqadd_s64(int64x1_t a, int64x1_t b) {
// CHECK: test_vqadd_s64
  return vqadd_s64(a, b);
// CHECK:  sqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint8x8_t test_vqadd_u8(uint8x8_t a, uint8x8_t b) {
// CHECK: test_vqadd_u8
  return vqadd_u8(a, b);
  // CHECK: uqadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vqadd_u16(uint16x4_t a, uint16x4_t b) {
// CHECK: test_vqadd_u16
  return vqadd_u16(a, b);
  // CHECK: uqadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vqadd_u32(uint32x2_t a, uint32x2_t b) {
// CHECK: test_vqadd_u32
  return vqadd_u32(a, b);
  // CHECK: uqadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint64x1_t test_vqadd_u64(uint64x1_t a, uint64x1_t b) {
// CHECK:  test_vqadd_u64
  return vqadd_u64(a, b);
// CHECK:  uqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8x16_t test_vqaddq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vqaddq_s8
  return vqaddq_s8(a, b);
  // CHECK: sqadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vqaddq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vqaddq_s16
  return vqaddq_s16(a, b);
  // CHECK: sqadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vqaddq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vqaddq_s32
  return vqaddq_s32(a, b);
  // CHECK: sqadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int64x2_t test_vqaddq_s64(int64x2_t a, int64x2_t b) {
// CHECK: test_vqaddq_s64
  return vqaddq_s64(a, b);
// CHECK: sqadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint8x16_t test_vqaddq_u8(uint8x16_t a, uint8x16_t b) {
// CHECK: test_vqaddq_u8
  return vqaddq_u8(a, b);
  // CHECK: uqadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vqaddq_u16(uint16x8_t a, uint16x8_t b) {
// CHECK: test_vqaddq_u16
  return vqaddq_u16(a, b);
  // CHECK: uqadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vqaddq_u32(uint32x4_t a, uint32x4_t b) {
// CHECK: test_vqaddq_u32
  return vqaddq_u32(a, b);
  // CHECK: uqadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vqaddq_u64(uint64x2_t a, uint64x2_t b) {
// CHECK: test_vqaddq_u64
  return vqaddq_u64(a, b);
// CHECK: uqadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}


int8x8_t test_vqsub_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vqsub_s8
  return vqsub_s8(a, b);
  // CHECK: sqsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vqsub_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vqsub_s16
  return vqsub_s16(a, b);
  // CHECK: sqsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vqsub_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vqsub_s32
  return vqsub_s32(a, b);
  // CHECK: sqsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int64x1_t test_vqsub_s64(int64x1_t a, int64x1_t b) {
// CHECK: test_vqsub_s64
  return vqsub_s64(a, b);
// CHECK: sqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint8x8_t test_vqsub_u8(uint8x8_t a, uint8x8_t b) {
// CHECK: test_vqsub_u8
  return vqsub_u8(a, b);
  // CHECK: uqsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vqsub_u16(uint16x4_t a, uint16x4_t b) {
// CHECK: test_vqsub_u16
  return vqsub_u16(a, b);
  // CHECK: uqsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vqsub_u32(uint32x2_t a, uint32x2_t b) {
// CHECK: test_vqsub_u32
  return vqsub_u32(a, b);
  // CHECK: uqsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint64x1_t test_vqsub_u64(uint64x1_t a, uint64x1_t b) {
// CHECK: test_vqsub_u64
  return vqsub_u64(a, b);
// CHECK:  uqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8x16_t test_vqsubq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vqsubq_s8
  return vqsubq_s8(a, b);
  // CHECK: sqsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vqsubq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vqsubq_s16
  return vqsubq_s16(a, b);
  // CHECK: sqsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vqsubq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vqsubq_s32
  return vqsubq_s32(a, b);
  // CHECK: sqsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int64x2_t test_vqsubq_s64(int64x2_t a, int64x2_t b) {
// CHECK: test_vqsubq_s64
  return vqsubq_s64(a, b);
// CHECK: sqsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint8x16_t test_vqsubq_u8(uint8x16_t a, uint8x16_t b) {
// CHECK: test_vqsubq_u8
  return vqsubq_u8(a, b);
  // CHECK: uqsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vqsubq_u16(uint16x8_t a, uint16x8_t b) {
// CHECK: test_vqsubq_u16
  return vqsubq_u16(a, b);
  // CHECK: uqsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vqsubq_u32(uint32x4_t a, uint32x4_t b) {
// CHECK: test_vqsubq_u32
  return vqsubq_u32(a, b);
  // CHECK: uqsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vqsubq_u64(uint64x2_t a, uint64x2_t b) {
// CHECK: test_vqsubq_u64
  return vqsubq_u64(a, b);
  // CHECK: uqsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}


int8x8_t test_vshl_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vshl_s8
  return vshl_s8(a, b);
// CHECK: sshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vshl_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vshl_s16
  return vshl_s16(a, b);
// CHECK: sshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vshl_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vshl_s32
  return vshl_s32(a, b);
// CHECK: sshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int64x1_t test_vshl_s64(int64x1_t a, int64x1_t b) {
// CHECK: test_vshl_s64
  return vshl_s64(a, b);
// CHECK: sshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint8x8_t test_vshl_u8(uint8x8_t a, int8x8_t b) {
// CHECK: test_vshl_u8
  return vshl_u8(a, b);
// CHECK: ushl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vshl_u16(uint16x4_t a, int16x4_t b) {
// CHECK: test_vshl_u16
  return vshl_u16(a, b);
// CHECK: ushl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vshl_u32(uint32x2_t a, int32x2_t b) {
// CHECK: test_vshl_u32
  return vshl_u32(a, b);
// CHECK: ushl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint64x1_t test_vshl_u64(uint64x1_t a, int64x1_t b) {
// CHECK: test_vshl_u64
  return vshl_u64(a, b);
// CHECK: ushl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8x16_t test_vshlq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vshlq_s8
  return vshlq_s8(a, b);
// CHECK: sshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vshlq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vshlq_s16
  return vshlq_s16(a, b);
// CHECK: sshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vshlq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vshlq_s32
  return vshlq_s32(a, b);
// CHECK: sshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int64x2_t test_vshlq_s64(int64x2_t a, int64x2_t b) {
// CHECK: test_vshlq_s64
  return vshlq_s64(a, b);
// CHECK: sshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint8x16_t test_vshlq_u8(uint8x16_t a, int8x16_t b) {
// CHECK: test_vshlq_u8
  return vshlq_u8(a, b);
// CHECK: ushl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vshlq_u16(uint16x8_t a, int16x8_t b) {
// CHECK: test_vshlq_u16
  return vshlq_u16(a, b);
// CHECK: ushl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vshlq_u32(uint32x4_t a, int32x4_t b) {
// CHECK: test_vshlq_u32
  return vshlq_u32(a, b);
// CHECK: ushl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vshlq_u64(uint64x2_t a, int64x2_t b) {
// CHECK: test_vshlq_u64
  return vshlq_u64(a, b);
// CHECK: ushl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}


int8x8_t test_vqshl_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vqshl_s8
  return vqshl_s8(a, b);
// CHECK: sqshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vqshl_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vqshl_s16
  return vqshl_s16(a, b);
// CHECK: sqshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vqshl_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vqshl_s32
  return vqshl_s32(a, b);
// CHECK: sqshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int64x1_t test_vqshl_s64(int64x1_t a, int64x1_t b) {
// CHECK: test_vqshl_s64
  return vqshl_s64(a, b);
// CHECK: sqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint8x8_t test_vqshl_u8(uint8x8_t a, int8x8_t b) {
// CHECK: test_vqshl_u8
  return vqshl_u8(a, b);
// CHECK: uqshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vqshl_u16(uint16x4_t a, int16x4_t b) {
// CHECK: test_vqshl_u16
  return vqshl_u16(a, b);
// CHECK: uqshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vqshl_u32(uint32x2_t a, int32x2_t b) {
// CHECK: test_vqshl_u32
  return vqshl_u32(a, b);
// CHECK: uqshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint64x1_t test_vqshl_u64(uint64x1_t a, int64x1_t b) {
// CHECK: test_vqshl_u64
  return vqshl_u64(a, b);
// CHECK: uqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8x16_t test_vqshlq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vqshlq_s8
  return vqshlq_s8(a, b);
// CHECK: sqshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vqshlq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vqshlq_s16
  return vqshlq_s16(a, b);
// CHECK: sqshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vqshlq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vqshlq_s32
  return vqshlq_s32(a, b);
// CHECK: sqshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int64x2_t test_vqshlq_s64(int64x2_t a, int64x2_t b) {
// CHECK: test_vqshlq_s64
  return vqshlq_s64(a, b);
// CHECK: sqshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint8x16_t test_vqshlq_u8(uint8x16_t a, int8x16_t b) {
// CHECK: test_vqshlq_u8
  return vqshlq_u8(a, b);
// CHECK: uqshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vqshlq_u16(uint16x8_t a, int16x8_t b) {
// CHECK: test_vqshlq_u16
  return vqshlq_u16(a, b);
// CHECK: uqshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vqshlq_u32(uint32x4_t a, int32x4_t b) {
// CHECK: test_vqshlq_u32
  return vqshlq_u32(a, b);
// CHECK: uqshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vqshlq_u64(uint64x2_t a, int64x2_t b) {
// CHECK: test_vqshlq_u32
  return vqshlq_u64(a, b);
// CHECK: uqshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vrshl_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vrshl_s8
  return vrshl_s8(a, b);
// CHECK: srshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vrshl_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vrshl_s16
  return vrshl_s16(a, b);
// CHECK: srshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vrshl_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vrshl_s32
  return vrshl_s32(a, b);
// CHECK: srshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int64x1_t test_vrshl_s64(int64x1_t a, int64x1_t b) {
// CHECK: test_vrshl_s64
  return vrshl_s64(a, b);
// CHECK: srshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint8x8_t test_vrshl_u8(uint8x8_t a, int8x8_t b) {
// CHECK: test_vrshl_u8
  return vrshl_u8(a, b);
// CHECK: urshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vrshl_u16(uint16x4_t a, int16x4_t b) {
// CHECK: test_vrshl_u16
  return vrshl_u16(a, b);
// CHECK: urshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vrshl_u32(uint32x2_t a, int32x2_t b) {
// CHECK: test_vrshl_u32
  return vrshl_u32(a, b);
// CHECK: urshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint64x1_t test_vrshl_u64(uint64x1_t a, int64x1_t b) {
// CHECK: test_vrshl_u64
  return vrshl_u64(a, b);
// CHECK: urshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8x16_t test_vrshlq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vrshlq_s8
  return vrshlq_s8(a, b);
// CHECK: srshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vrshlq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vrshlq_s16
  return vrshlq_s16(a, b);
// CHECK: srshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vrshlq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vrshlq_s32
  return vrshlq_s32(a, b);
// CHECK: srshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int64x2_t test_vrshlq_s64(int64x2_t a, int64x2_t b) {
// CHECK: test_vrshlq_s64
  return vrshlq_s64(a, b);
// CHECK: srshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

uint8x16_t test_vrshlq_u8(uint8x16_t a, int8x16_t b) {
// CHECK: test_vrshlq_u8
  return vrshlq_u8(a, b);
// CHECK: urshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vrshlq_u16(uint16x8_t a, int16x8_t b) {
// CHECK: test_vrshlq_u16
  return vrshlq_u16(a, b);
// CHECK: urshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vrshlq_u32(uint32x4_t a, int32x4_t b) {
// CHECK: test_vrshlq_u32
  return vrshlq_u32(a, b);
// CHECK: urshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vrshlq_u64(uint64x2_t a, int64x2_t b) {
// CHECK: test_vrshlq_u64
  return vrshlq_u64(a, b);
// CHECK: urshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}


int8x8_t test_vqrshl_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vqrshl_s8
  return vqrshl_s8(a, b);
// CHECK: sqrshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vqrshl_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vqrshl_s16
  return vqrshl_s16(a, b);
// CHECK: sqrshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vqrshl_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vqrshl_s32
  return vqrshl_s32(a, b);
// CHECK: sqrshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int64x1_t test_vqrshl_s64(int64x1_t a, int64x1_t b) {
// CHECK: test_vqrshl_s64
  return vqrshl_s64(a, b);
// CHECK: sqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint8x8_t test_vqrshl_u8(uint8x8_t a, int8x8_t b) {
// CHECK: test_vqrshl_u8
  return vqrshl_u8(a, b);
// CHECK: uqrshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vqrshl_u16(uint16x4_t a, int16x4_t b) {
// CHECK: test_vqrshl_u16
  return vqrshl_u16(a, b);
// CHECK: uqrshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vqrshl_u32(uint32x2_t a, int32x2_t b) {
// CHECK: test_vqrshl_u32
  return vqrshl_u32(a, b);
// CHECK: uqrshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint64x1_t test_vqrshl_u64(uint64x1_t a, int64x1_t b) {
// CHECK: test_vqrshl_u64
  return vqrshl_u64(a, b);
// CHECK: uqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8x16_t test_vqrshlq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vqrshlq_s8
  return vqrshlq_s8(a, b);
// CHECK: sqrshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vqrshlq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vqrshlq_s16
  return vqrshlq_s16(a, b);
// CHECK: sqrshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vqrshlq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vqrshlq_s32
  return vqrshlq_s32(a, b);
// CHECK: sqrshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int64x2_t test_vqrshlq_s64(int64x2_t a, int64x2_t b) {
// CHECK: test_vqrshlq_s64
  return vqrshlq_s64(a, b);
// CHECK: sqrshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

// CHECK: test_vqrshlq_u8
uint8x16_t test_vqrshlq_u8(uint8x16_t a, int8x16_t b) {
  return vqrshlq_u8(a, b);
// CHECK: uqrshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vqrshlq_u16(uint16x8_t a, int16x8_t b) {
// CHECK: test_vqrshlq_u16
  return vqrshlq_u16(a, b);
// CHECK: uqrshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vqrshlq_u32(uint32x4_t a, int32x4_t b) {
// CHECK: test_vqrshlq_u32
  return vqrshlq_u32(a, b);
// CHECK: uqrshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint64x2_t test_vqrshlq_u64(uint64x2_t a, int64x2_t b) {
// CHECK: test_vqrshlq_u64
  return vqrshlq_u64(a, b);
// CHECK: uqrshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vmax_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vmax_s8
  return vmax_s8(a, b);
// CHECK: smax {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vmax_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vmax_s16
  return vmax_s16(a, b);
// CHECK: smax {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vmax_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vmax_s32
  return vmax_s32(a, b);
// CHECK: smax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vmax_u8(uint8x8_t a, uint8x8_t b) {
// CHECK: test_vmax_u8
  return vmax_u8(a, b);
// CHECK: umax {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vmax_u16(uint16x4_t a, uint16x4_t b) {
// CHECK: test_vmax_u16
  return vmax_u16(a, b);
// CHECK: umax {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vmax_u32(uint32x2_t a, uint32x2_t b) {
// CHECK: test_vmax_u32
  return vmax_u32(a, b);
// CHECK: umax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vmax_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vmax_f32
  return vmax_f32(a, b);
// CHECK: fmax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vmaxq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vmaxq_s8
  return vmaxq_s8(a, b);
// CHECK: smax {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vmaxq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vmaxq_s16
  return vmaxq_s16(a, b);
// CHECK: smax {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vmaxq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vmaxq_s32
  return vmaxq_s32(a, b);
// CHECK: smax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vmaxq_u8(uint8x16_t a, uint8x16_t b) {
// CHECK: test_vmaxq_u8
  return vmaxq_u8(a, b);
// CHECK: umax {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vmaxq_u16(uint16x8_t a, uint16x8_t b) {
// CHECK: test_vmaxq_u16
  return vmaxq_u16(a, b);
// CHECK: umax {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vmaxq_u32(uint32x4_t a, uint32x4_t b) {
// CHECK: test_vmaxq_u32
  return vmaxq_u32(a, b);
// CHECK: umax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x4_t test_vmaxq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vmaxq_f32
  return vmaxq_f32(a, b);
// CHECK: fmax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vmaxq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vmaxq_f64
  return vmaxq_f64(a, b);
// CHECK: fmax {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}


int8x8_t test_vmin_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vmin_s8
  return vmin_s8(a, b);
// CHECK: smin {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vmin_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vmin_s16
  return vmin_s16(a, b);
// CHECK: smin {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vmin_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vmin_s32
  return vmin_s32(a, b);
// CHECK: smin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vmin_u8(uint8x8_t a, uint8x8_t b) {
// CHECK: test_vmin_u8
  return vmin_u8(a, b);
// CHECK: umin {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vmin_u16(uint16x4_t a, uint16x4_t b) {
// CHECK: test_vmin_u16
  return vmin_u16(a, b);
// CHECK: umin {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vmin_u32(uint32x2_t a, uint32x2_t b) {
// CHECK: test_vmin_u32
  return vmin_u32(a, b);
// CHECK: umin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vmin_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vmin_f32
  return vmin_f32(a, b);
// CHECK: fmin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vminq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vminq_s8
  return vminq_s8(a, b);
// CHECK: smin {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vminq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vminq_s16
  return vminq_s16(a, b);
// CHECK: smin {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vminq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vminq_s32
  return vminq_s32(a, b);
// CHECK: smin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vminq_u8(uint8x16_t a, uint8x16_t b) {
// CHECK: test_vminq_u8
  return vminq_u8(a, b);
// CHECK: umin {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vminq_u16(uint16x8_t a, uint16x8_t b) {
// CHECK: test_vminq_u16
  return vminq_u16(a, b);
// CHECK: umin {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vminq_u32(uint32x4_t a, uint32x4_t b) {
// CHECK: test_vminq_u32
  return vminq_u32(a, b);
// CHECK: umin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x4_t test_vminq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vminq_f32
  return vminq_f32(a, b);
// CHECK: fmin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vminq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vminq_f64
  return vminq_f64(a, b);
// CHECK: fmin {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

float32x2_t test_vmaxnm_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vmaxnm_f32
  return vmaxnm_f32(a, b);
// CHECK: fmaxnm {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x4_t test_vmaxnmq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vmaxnmq_f32
  return vmaxnmq_f32(a, b);
// CHECK: fmaxnm {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vmaxnmq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vmaxnmq_f64
  return vmaxnmq_f64(a, b);
// CHECK: fmaxnm {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

float32x2_t test_vminnm_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vminnm_f32
  return vminnm_f32(a, b);
// CHECK: fminnm {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x4_t test_vminnmq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vminnmq_f32
  return vminnmq_f32(a, b);
// CHECK: fminnm {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vminnmq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vminnmq_f64
  return vminnmq_f64(a, b);
// CHECK: fminnm {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vpmax_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vpmax_s8
  return vpmax_s8(a, b);
// CHECK: smaxp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vpmax_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vpmax_s16
  return vpmax_s16(a, b);
// CHECK: smaxp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vpmax_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vpmax_s32
  return vpmax_s32(a, b);
// CHECK: smaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vpmax_u8(uint8x8_t a, uint8x8_t b) {
// CHECK: test_vpmax_u8
  return vpmax_u8(a, b);
// CHECK: umaxp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vpmax_u16(uint16x4_t a, uint16x4_t b) {
// CHECK: test_vpmax_u16
  return vpmax_u16(a, b);
// CHECK: umaxp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vpmax_u32(uint32x2_t a, uint32x2_t b) {
// CHECK: test_vpmax_u32
  return vpmax_u32(a, b);
// CHECK: umaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vpmax_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vpmax_f32
  return vpmax_f32(a, b);
// CHECK: fmaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vpmaxq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vpmaxq_s8
  return vpmaxq_s8(a, b);
// CHECK: smaxp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vpmaxq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vpmaxq_s16
  return vpmaxq_s16(a, b);
// CHECK: smaxp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vpmaxq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vpmaxq_s32
  return vpmaxq_s32(a, b);
// CHECK: smaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vpmaxq_u8(uint8x16_t a, uint8x16_t b) {
// CHECK: test_vpmaxq_u8
  return vpmaxq_u8(a, b);
// CHECK: umaxp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vpmaxq_u16(uint16x8_t a, uint16x8_t b) {
// CHECK: test_vpmaxq_u16
  return vpmaxq_u16(a, b);
// CHECK: umaxp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vpmaxq_u32(uint32x4_t a, uint32x4_t b) {
// CHECK: test_vpmaxq_u32
  return vpmaxq_u32(a, b);
// CHECK: umaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x4_t test_vpmaxq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vpmaxq_f32
  return vpmaxq_f32(a, b);
// CHECK: fmaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vpmaxq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vpmaxq_f64
  return vpmaxq_f64(a, b);
// CHECK: fmaxp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vpmin_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vpmin_s8
  return vpmin_s8(a, b);
// CHECK: sminp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vpmin_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vpmin_s16
  return vpmin_s16(a, b);
// CHECK: sminp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vpmin_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vpmin_s32
  return vpmin_s32(a, b);
// CHECK: sminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vpmin_u8(uint8x8_t a, uint8x8_t b) {
// CHECK: test_vpmin_u8
  return vpmin_u8(a, b);
// CHECK: uminp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vpmin_u16(uint16x4_t a, uint16x4_t b) {
// CHECK: test_vpmin_u16
  return vpmin_u16(a, b);
// CHECK: uminp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vpmin_u32(uint32x2_t a, uint32x2_t b) {
// CHECK: test_vpmin_u32
  return vpmin_u32(a, b);
// CHECK: uminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vpmin_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vpmin_f32
  return vpmin_f32(a, b);
// CHECK: fminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vpminq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vpminq_s8
  return vpminq_s8(a, b);
// CHECK: sminp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vpminq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vpminq_s16
  return vpminq_s16(a, b);
// CHECK: sminp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vpminq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vpminq_s32
  return vpminq_s32(a, b);
// CHECK: sminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vpminq_u8(uint8x16_t a, uint8x16_t b) {
// CHECK: test_vpminq_u8
  return vpminq_u8(a, b);
// CHECK: uminp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vpminq_u16(uint16x8_t a, uint16x8_t b) {
// CHECK: test_vpminq_u16
  return vpminq_u16(a, b);
// CHECK: uminp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vpminq_u32(uint32x4_t a, uint32x4_t b) {
// CHECK: test_vpminq_u32
  return vpminq_u32(a, b);
// CHECK: uminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x4_t test_vpminq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vpminq_f32
  return vpminq_f32(a, b);
// CHECK: fminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vpminq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vpminq_f64
  return vpminq_f64(a, b);
// CHECK: fminp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

float32x2_t test_vpmaxnm_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vpmaxnm_f32
  return vpmaxnm_f32(a, b);
// CHECK: fmaxnmp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x4_t test_vpmaxnmq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vpmaxnmq_f32
  return vpmaxnmq_f32(a, b);
// CHECK: fmaxnmp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vpmaxnmq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vpmaxnmq_f64
  return vpmaxnmq_f64(a, b);
// CHECK: fmaxnmp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

float32x2_t test_vpminnm_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vpminnm_f32
  return vpminnm_f32(a, b);
// CHECK: fminnmp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x4_t test_vpminnmq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vpminnmq_f32
  return vpminnmq_f32(a, b);
// CHECK: fminnmp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vpminnmq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vpminnmq_f64
  return vpminnmq_f64(a, b);
// CHECK: fminnmp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vpadd_s8(int8x8_t a, int8x8_t b) {
// CHECK: test_vpadd_s8
  return vpadd_s8(a, b);
// CHECK: addp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

int16x4_t test_vpadd_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vpadd_s16
  return vpadd_s16(a, b);
// CHECK: addp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vpadd_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vpadd_s32
  return vpadd_s32(a, b);
// CHECK: addp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

uint8x8_t test_vpadd_u8(uint8x8_t a, uint8x8_t b) {
// CHECK: test_vpadd_u8
  return vpadd_u8(a, b);
// CHECK: addp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
}

uint16x4_t test_vpadd_u16(uint16x4_t a, uint16x4_t b) {
// CHECK: test_vpadd_u16
  return vpadd_u16(a, b);
// CHECK: addp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

uint32x2_t test_vpadd_u32(uint32x2_t a, uint32x2_t b) {
// CHECK: test_vpadd_u32
  return vpadd_u32(a, b);
// CHECK: addp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x2_t test_vpadd_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vpadd_f32
  return vpadd_f32(a, b);
// CHECK: faddp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int8x16_t test_vpaddq_s8(int8x16_t a, int8x16_t b) {
// CHECK: test_vpaddq_s8
  return vpaddq_s8(a, b);
// CHECK: addp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

int16x8_t test_vpaddq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vpaddq_s16
  return vpaddq_s16(a, b);
// CHECK: addp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vpaddq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vpaddq_s32
  return vpaddq_s32(a, b);
// CHECK: addp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

uint8x16_t test_vpaddq_u8(uint8x16_t a, uint8x16_t b) {
// CHECK: test_vpaddq_u8
  return vpaddq_u8(a, b);
// CHECK: addp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
}

uint16x8_t test_vpaddq_u16(uint16x8_t a, uint16x8_t b) {
// CHECK: test_vpaddq_u16
  return vpaddq_u16(a, b);
// CHECK: addp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

uint32x4_t test_vpaddq_u32(uint32x4_t a, uint32x4_t b) {
// CHECK: test_vpaddq_u32
  return vpaddq_u32(a, b);
// CHECK: addp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float32x4_t test_vpaddq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vpaddq_f32
  return vpaddq_f32(a, b);
// CHECK: faddp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vpaddq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vpaddq_f64
  return vpaddq_f64(a, b);
// CHECK: faddp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int16x4_t test_vqdmulh_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vqdmulh_s16
  return vqdmulh_s16(a, b);
// CHECK: sqdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vqdmulh_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vqdmulh_s32
  return vqdmulh_s32(a, b);
// CHECK: sqdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int16x8_t test_vqdmulhq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vqdmulhq_s16
  return vqdmulhq_s16(a, b);
// CHECK: sqdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vqdmulhq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vqdmulhq_s32
  return vqdmulhq_s32(a, b);
// CHECK: sqdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

int16x4_t test_vqrdmulh_s16(int16x4_t a, int16x4_t b) {
// CHECK: test_vqrdmulh_s16
  return vqrdmulh_s16(a, b);
// CHECK: sqrdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
}

int32x2_t test_vqrdmulh_s32(int32x2_t a, int32x2_t b) {
// CHECK: test_vqrdmulh_s32
  return vqrdmulh_s32(a, b);
// CHECK: sqrdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

int16x8_t test_vqrdmulhq_s16(int16x8_t a, int16x8_t b) {
// CHECK: test_vqrdmulhq_s16
  return vqrdmulhq_s16(a, b);
// CHECK: sqrdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
}

int32x4_t test_vqrdmulhq_s32(int32x4_t a, int32x4_t b) {
// CHECK: test_vqrdmulhq_s32
  return vqrdmulhq_s32(a, b);
// CHECK: sqrdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}


float32x2_t test_vmulx_f32(float32x2_t a, float32x2_t b) {
// CHECK: test_vmulx_f32
  return vmulx_f32(a, b);
// CHECK: fmulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
}

float32x4_t test_vmulxq_f32(float32x4_t a, float32x4_t b) {
// CHECK: test_vmulxq_f32
  return vmulxq_f32(a, b);
// CHECK: fmulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
}

float64x2_t test_vmulxq_f64(float64x2_t a, float64x2_t b) {
// CHECK: test_vmulxq_f64
  return vmulxq_f64(a, b);
// CHECK: fmulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
}

int8x8_t test_vshl_n_s8(int8x8_t a) {
// CHECK: test_vshl_n_s8
  return vshl_n_s8(a, 3);
// CHECK: shl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vshl_n_s16(int16x4_t a) {
// CHECK: test_vshl_n_s16
  return vshl_n_s16(a, 3);
// CHECK: shl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vshl_n_s32(int32x2_t a) {
// CHECK: test_vshl_n_s32
  return vshl_n_s32(a, 3);
// CHECK: shl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vshlq_n_s8(int8x16_t a) {
// CHECK: test_vshlq_n_s8
  return vshlq_n_s8(a, 3);
// CHECK: shl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vshlq_n_s16(int16x8_t a) {
// CHECK: test_vshlq_n_s16
  return vshlq_n_s16(a, 3);
// CHECK: shl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vshlq_n_s32(int32x4_t a) {
// CHECK: test_vshlq_n_s32
  return vshlq_n_s32(a, 3);
// CHECK: shl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vshlq_n_s64(int64x2_t a) {
// CHECK: test_vshlq_n_s64
  return vshlq_n_s64(a, 3);
// CHECK: shl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vshl_n_u8(int8x8_t a) {
// CHECK: test_vshl_n_u8
  return vshl_n_u8(a, 3);
// CHECK: shl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vshl_n_u16(int16x4_t a) {
// CHECK: test_vshl_n_u16
  return vshl_n_u16(a, 3);
// CHECK: shl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vshl_n_u32(int32x2_t a) {
// CHECK: test_vshl_n_u32
  return vshl_n_u32(a, 3);
// CHECK: shl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vshlq_n_u8(int8x16_t a) {
// CHECK: test_vshlq_n_u8
  return vshlq_n_u8(a, 3);
// CHECK: shl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vshlq_n_u16(int16x8_t a) {
// CHECK: test_vshlq_n_u16
  return vshlq_n_u16(a, 3);
// CHECK: shl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vshlq_n_u32(int32x4_t a) {
// CHECK: test_vshlq_n_u32
  return vshlq_n_u32(a, 3);
// CHECK: shl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vshlq_n_u64(int64x2_t a) {
// CHECK: test_vshlq_n_u64
  return vshlq_n_u64(a, 3);
// CHECK: shl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vshr_n_s8(int8x8_t a) {
  // CHECK: test_vshr_n_s8
  return vshr_n_s8(a, 3);
  // CHECK: sshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vshr_n_s16(int16x4_t a) {
  // CHECK: test_vshr_n_s16
  return vshr_n_s16(a, 3);
  // CHECK: sshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vshr_n_s32(int32x2_t a) {
  // CHECK: test_vshr_n_s32
  return vshr_n_s32(a, 3);
  // CHECK: sshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vshrq_n_s8(int8x16_t a) {
  // CHECK: test_vshrq_n_s8
  return vshrq_n_s8(a, 3);
  // CHECK: sshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vshrq_n_s16(int16x8_t a) {
  // CHECK: test_vshrq_n_s16
  return vshrq_n_s16(a, 3);
  // CHECK: sshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vshrq_n_s32(int32x4_t a) {
  // CHECK: test_vshrq_n_s32
  return vshrq_n_s32(a, 3);
  // CHECK: sshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vshrq_n_s64(int64x2_t a) {
  // CHECK: test_vshrq_n_s64
  return vshrq_n_s64(a, 3);
  // CHECK: sshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vshr_n_u8(int8x8_t a) {
  // CHECK: test_vshr_n_u8
  return vshr_n_u8(a, 3);
  // CHECK: ushr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vshr_n_u16(int16x4_t a) {
  // CHECK: test_vshr_n_u16
  return vshr_n_u16(a, 3);
  // CHECK: ushr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vshr_n_u32(int32x2_t a) {
  // CHECK: test_vshr_n_u32
  return vshr_n_u32(a, 3);
  // CHECK: ushr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vshrq_n_u8(int8x16_t a) {
  // CHECK: test_vshrq_n_u8
  return vshrq_n_u8(a, 3);
  // CHECK: ushr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vshrq_n_u16(int16x8_t a) {
  // CHECK: test_vshrq_n_u16
  return vshrq_n_u16(a, 3);
  // CHECK: ushr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vshrq_n_u32(int32x4_t a) {
  // CHECK: test_vshrq_n_u32
  return vshrq_n_u32(a, 3);
  // CHECK: ushr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vshrq_n_u64(int64x2_t a) {
  // CHECK: test_vshrq_n_u64
  return vshrq_n_u64(a, 3);
  // CHECK: ushr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vsra_n_s8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vsra_n_s8
  return vsra_n_s8(a, b, 3);
  // CHECK: ssra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vsra_n_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vsra_n_s16
  return vsra_n_s16(a, b, 3);
  // CHECK: ssra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vsra_n_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vsra_n_s32
  return vsra_n_s32(a, b, 3);
  // CHECK: ssra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vsraq_n_s8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vsraq_n_s8
  return vsraq_n_s8(a, b, 3);
  // CHECK: ssra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vsraq_n_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vsraq_n_s16
  return vsraq_n_s16(a, b, 3);
  // CHECK: ssra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vsraq_n_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vsraq_n_s32
  return vsraq_n_s32(a, b, 3);
  // CHECK: ssra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vsraq_n_s64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vsraq_n_s64
  return vsraq_n_s64(a, b, 3);
  // CHECK: ssra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vsra_n_u8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vsra_n_u8
  return vsra_n_u8(a, b, 3);
  // CHECK: usra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vsra_n_u16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vsra_n_u16
  return vsra_n_u16(a, b, 3);
  // CHECK: usra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vsra_n_u32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vsra_n_u32
  return vsra_n_u32(a, b, 3);
  // CHECK: usra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vsraq_n_u8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vsraq_n_u8
  return vsraq_n_u8(a, b, 3);
  // CHECK: usra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vsraq_n_u16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vsraq_n_u16
  return vsraq_n_u16(a, b, 3);
  // CHECK: usra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vsraq_n_u32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vsraq_n_u32
  return vsraq_n_u32(a, b, 3);
  // CHECK: usra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vsraq_n_u64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vsraq_n_u64
  return vsraq_n_u64(a, b, 3);
  // CHECK: usra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vrshr_n_s8(int8x8_t a) {
  // CHECK: test_vrshr_n_s8
  return vrshr_n_s8(a, 3);
  // CHECK: srshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vrshr_n_s16(int16x4_t a) {
  // CHECK: test_vrshr_n_s16
  return vrshr_n_s16(a, 3);
  // CHECK: srshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vrshr_n_s32(int32x2_t a) {
  // CHECK: test_vrshr_n_s32
  return vrshr_n_s32(a, 3);
  // CHECK: srshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vrshrq_n_s8(int8x16_t a) {
  // CHECK: test_vrshrq_n_s8
  return vrshrq_n_s8(a, 3);
  // CHECK: srshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vrshrq_n_s16(int16x8_t a) {
  // CHECK: test_vrshrq_n_s16
  return vrshrq_n_s16(a, 3);
  // CHECK: srshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vrshrq_n_s32(int32x4_t a) {
  // CHECK: test_vrshrq_n_s32
  return vrshrq_n_s32(a, 3);
  // CHECK: srshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vrshrq_n_s64(int64x2_t a) {
  // CHECK: test_vrshrq_n_s64
  return vrshrq_n_s64(a, 3);
  // CHECK: srshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vrshr_n_u8(int8x8_t a) {
  // CHECK: test_vrshr_n_u8
  return vrshr_n_u8(a, 3);
  // CHECK: urshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vrshr_n_u16(int16x4_t a) {
  // CHECK: test_vrshr_n_u16
  return vrshr_n_u16(a, 3);
  // CHECK: urshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vrshr_n_u32(int32x2_t a) {
  // CHECK: test_vrshr_n_u32
  return vrshr_n_u32(a, 3);
  // CHECK: urshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vrshrq_n_u8(int8x16_t a) {
  // CHECK: test_vrshrq_n_u8
  return vrshrq_n_u8(a, 3);
  // CHECK: urshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vrshrq_n_u16(int16x8_t a) {
  // CHECK: test_vrshrq_n_u16
  return vrshrq_n_u16(a, 3);
  // CHECK: urshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vrshrq_n_u32(int32x4_t a) {
  // CHECK: test_vrshrq_n_u32
  return vrshrq_n_u32(a, 3);
  // CHECK: urshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vrshrq_n_u64(int64x2_t a) {
  // CHECK: test_vrshrq_n_u64
  return vrshrq_n_u64(a, 3);
  // CHECK: urshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vrsra_n_s8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vrsra_n_s8
  return vrsra_n_s8(a, b, 3);
  // CHECK: srsra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vrsra_n_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vrsra_n_s16
  return vrsra_n_s16(a, b, 3);
  // CHECK: srsra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vrsra_n_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vrsra_n_s32
  return vrsra_n_s32(a, b, 3);
  // CHECK: srsra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vrsraq_n_s8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vrsraq_n_s8
  return vrsraq_n_s8(a, b, 3);
  // CHECK: srsra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vrsraq_n_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vrsraq_n_s16
  return vrsraq_n_s16(a, b, 3);
  // CHECK: srsra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vrsraq_n_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vrsraq_n_s32
  return vrsraq_n_s32(a, b, 3);
  // CHECK: srsra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vrsraq_n_s64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vrsraq_n_s64
  return vrsraq_n_s64(a, b, 3);
  // CHECK: srsra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vrsra_n_u8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vrsra_n_u8
  return vrsra_n_u8(a, b, 3);
  // CHECK: ursra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vrsra_n_u16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vrsra_n_u16
  return vrsra_n_u16(a, b, 3);
  // CHECK: ursra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vrsra_n_u32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vrsra_n_u32
  return vrsra_n_u32(a, b, 3);
  // CHECK: ursra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vrsraq_n_u8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vrsraq_n_u8
  return vrsraq_n_u8(a, b, 3);
  // CHECK: ursra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vrsraq_n_u16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vrsraq_n_u16
  return vrsraq_n_u16(a, b, 3);
  // CHECK: ursra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vrsraq_n_u32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vrsraq_n_u32
  return vrsraq_n_u32(a, b, 3);
  // CHECK: ursra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vrsraq_n_u64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vrsraq_n_u64
  return vrsraq_n_u64(a, b, 3);
  // CHECK: ursra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vsri_n_s8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vsri_n_s8
  return vsri_n_s8(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vsri_n_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vsri_n_s16
  return vsri_n_s16(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vsri_n_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vsri_n_s32
  return vsri_n_s32(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vsriq_n_s8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vsriq_n_s8
  return vsriq_n_s8(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vsriq_n_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vsriq_n_s16
  return vsriq_n_s16(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vsriq_n_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vsriq_n_s32
  return vsriq_n_s32(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vsriq_n_s64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vsriq_n_s64
  return vsriq_n_s64(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vsri_n_u8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vsri_n_u8
  return vsri_n_u8(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vsri_n_u16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vsri_n_u16
  return vsri_n_u16(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vsri_n_u32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vsri_n_u32
  return vsri_n_u32(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vsriq_n_u8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vsriq_n_u8
  return vsriq_n_u8(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vsriq_n_u16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vsriq_n_u16
  return vsriq_n_u16(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vsriq_n_u32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vsriq_n_u32
  return vsriq_n_u32(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vsriq_n_u64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vsriq_n_u64
  return vsriq_n_u64(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

poly8x8_t test_vsri_n_p8(poly8x8_t a, poly8x8_t b) {
  // CHECK: test_vsri_n_p8
  return vsri_n_p8(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

poly16x4_t test_vsri_n_p16(poly16x4_t a, poly16x4_t b) {
  // CHECK: test_vsri_n_p16
  return vsri_n_p16(a, b, 15);
  // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #15
}

poly8x16_t test_vsriq_n_p8(poly8x16_t a, poly8x16_t b) {
  // CHECK: test_vsriq_n_p8
  return vsriq_n_p8(a, b, 3);
  // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

poly16x8_t test_vsriq_n_p16(poly16x8_t a, poly16x8_t b) {
  // CHECK: test_vsriq_n_p16
  return vsriq_n_p16(a, b, 15);
  // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #15
}

int8x8_t test_vsli_n_s8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vsli_n_s8
  return vsli_n_s8(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vsli_n_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vsli_n_s16
  return vsli_n_s16(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vsli_n_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vsli_n_s32
  return vsli_n_s32(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vsliq_n_s8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vsliq_n_s8
  return vsliq_n_s8(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vsliq_n_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vsliq_n_s16
  return vsliq_n_s16(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vsliq_n_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vsliq_n_s32
  return vsliq_n_s32(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vsliq_n_s64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vsliq_n_s64
  return vsliq_n_s64(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

uint8x8_t test_vsli_n_u8(uint8x8_t a, uint8x8_t b) {
  // CHECK: test_vsli_n_u8
  return vsli_n_u8(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

uint16x4_t test_vsli_n_u16(uint16x4_t a, uint16x4_t b) {
  // CHECK: test_vsli_n_u16
  return vsli_n_u16(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

uint32x2_t test_vsli_n_u32(uint32x2_t a, uint32x2_t b) {
  // CHECK: test_vsli_n_u32
  return vsli_n_u32(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

uint8x16_t test_vsliq_n_u8(uint8x16_t a, uint8x16_t b) {
  // CHECK: test_vsliq_n_u8
  return vsliq_n_u8(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

uint16x8_t test_vsliq_n_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vsliq_n_u16
  return vsliq_n_u16(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

uint32x4_t test_vsliq_n_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vsliq_n_u32
  return vsliq_n_u32(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

uint64x2_t test_vsliq_n_u64(uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vsliq_n_u64
  return vsliq_n_u64(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

poly8x8_t test_vsli_n_p8(poly8x8_t a, poly8x8_t b) {
  // CHECK: test_vsli_n_p8
  return vsli_n_p8(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

poly16x4_t test_vsli_n_p16(poly16x4_t a, poly16x4_t b) {
  // CHECK: test_vsli_n_p16
  return vsli_n_p16(a, b, 15);
  // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #15
}

poly8x16_t test_vsliq_n_p8(poly8x16_t a, poly8x16_t b) {
  // CHECK: test_vsliq_n_p8
  return vsliq_n_p8(a, b, 3);
  // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

poly16x8_t test_vsliq_n_p16(poly16x8_t a, poly16x8_t b) {
  // CHECK: test_vsliq_n_p16
  return vsliq_n_p16(a, b, 15);
  // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #15
}

int8x8_t test_vqshlu_n_s8(int8x8_t a) {
  // CHECK: test_vqshlu_n_s8
  return vqshlu_n_s8(a, 3);
  // CHECK: sqshlu {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
}

int16x4_t test_vqshlu_n_s16(int16x4_t a) {
  // CHECK: test_vqshlu_n_s16
  return vqshlu_n_s16(a, 3);
  // CHECK: sqshlu {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
}

int32x2_t test_vqshlu_n_s32(int32x2_t a) {
  // CHECK: test_vqshlu_n_s32
  return vqshlu_n_s32(a, 3);
  // CHECK: sqshlu {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
}

int8x16_t test_vqshluq_n_s8(int8x16_t a) {
  // CHECK: test_vqshluq_n_s8
  return vqshluq_n_s8(a, 3);
  // CHECK: sqshlu {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
}

int16x8_t test_vqshluq_n_s16(int16x8_t a) {
  // CHECK: test_vqshluq_n_s16
  return vqshluq_n_s16(a, 3);
  // CHECK: sqshlu {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
}

int32x4_t test_vqshluq_n_s32(int32x4_t a) {
  // CHECK: test_vqshluq_n_s32
  return vqshluq_n_s32(a, 3);
  // CHECK: sqshlu {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
}

int64x2_t test_vqshluq_n_s64(int64x2_t a) {
  // CHECK: test_vqshluq_n_s64
  return vqshluq_n_s64(a, 3);
  // CHECK: sqshlu {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
}

int8x8_t test_vshrn_n_s16(int16x8_t a) {
  // CHECK: test_vshrn_n_s16
  return vshrn_n_s16(a, 3);
  // CHECK: shrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

int16x4_t test_vshrn_n_s32(int32x4_t a) {
  // CHECK: test_vshrn_n_s32
  return vshrn_n_s32(a, 9);
  // CHECK: shrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

int32x2_t test_vshrn_n_s64(int64x2_t a) {
  // CHECK: test_vshrn_n_s64
  return vshrn_n_s64(a, 19);
  // CHECK: shrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

uint8x8_t test_vshrn_n_u16(uint16x8_t a) {
  // CHECK: test_vshrn_n_u16
  return vshrn_n_u16(a, 3);
  // CHECK: shrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

uint16x4_t test_vshrn_n_u32(uint32x4_t a) {
  // CHECK: test_vshrn_n_u32
  return vshrn_n_u32(a, 9);
  // CHECK: shrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

uint32x2_t test_vshrn_n_u64(uint64x2_t a) {
  // CHECK: test_vshrn_n_u64
  return vshrn_n_u64(a, 19);
  // CHECK: shrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

int8x16_t test_vshrn_high_n_s16(int8x8_t a, int16x8_t b) {
  // CHECK: test_vshrn_high_n_s16
  return vshrn_high_n_s16(a, b, 3);
  // CHECK: shrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

int16x8_t test_vshrn_high_n_s32(int16x4_t a, int32x4_t b) {
  // CHECK: test_vshrn_high_n_s32
  return vshrn_high_n_s32(a, b, 9);
  // CHECK: shrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

int32x4_t test_vshrn_high_n_s64(int32x2_t a, int64x2_t b) {
  // CHECK: test_vshrn_high_n_s64
  return vshrn_high_n_s64(a, b, 19);
  // CHECK: shrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

uint8x16_t test_vshrn_high_n_u16(uint8x8_t a, uint16x8_t b) {
  // CHECK: test_vshrn_high_n_u16
  return vshrn_high_n_u16(a, b, 3);
  // CHECK: shrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

uint16x8_t test_vshrn_high_n_u32(uint16x4_t a, uint32x4_t b) {
  // CHECK: test_vshrn_high_n_u32
  return vshrn_high_n_u32(a, b, 9);
  // CHECK: shrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

uint32x4_t test_vshrn_high_n_u64(uint32x2_t a, uint64x2_t b) {
  // CHECK: test_vshrn_high_n_u64
  return vshrn_high_n_u64(a, b, 19);
  // CHECK: shrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

int8x8_t test_vqshrun_n_s16(int16x8_t a) {
  // CHECK: test_vqshrun_n_s16
  return vqshrun_n_s16(a, 3);
  // CHECK: sqshrun {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

int16x4_t test_vqshrun_n_s32(int32x4_t a) {
  // CHECK: test_vqshrun_n_s32
  return vqshrun_n_s32(a, 9);
  // CHECK: sqshrun {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

int32x2_t test_vqshrun_n_s64(int64x2_t a) {
  // CHECK: test_vqshrun_n_s64
  return vqshrun_n_s64(a, 19);
  // CHECK: sqshrun {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

int8x16_t test_vqshrun_high_n_s16(int8x8_t a, int16x8_t b) {
  // CHECK: test_vqshrun_high_n_s16
  return vqshrun_high_n_s16(a, b, 3);
  // CHECK: sqshrun2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

int16x8_t test_vqshrun_high_n_s32(int16x4_t a, int32x4_t b) {
  // CHECK: test_vqshrun_high_n_s32
  return vqshrun_high_n_s32(a, b, 9);
  // CHECK: sqshrun2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

int32x4_t test_vqshrun_high_n_s64(int32x2_t a, int64x2_t b) {
  // CHECK: test_vqshrun_high_n_s64
  return vqshrun_high_n_s64(a, b, 19);
  // CHECK: sqshrun2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

int8x8_t test_vrshrn_n_s16(int16x8_t a) {
  // CHECK: test_vrshrn_n_s16
  return vrshrn_n_s16(a, 3);
  // CHECK: rshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

int16x4_t test_vrshrn_n_s32(int32x4_t a) {
  // CHECK: test_vrshrn_n_s32
  return vrshrn_n_s32(a, 9);
  // CHECK: rshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

int32x2_t test_vrshrn_n_s64(int64x2_t a) {
  // CHECK: test_vrshrn_n_s64
  return vrshrn_n_s64(a, 19);
  // CHECK: rshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

uint8x8_t test_vrshrn_n_u16(uint16x8_t a) {
  // CHECK: test_vrshrn_n_u16
  return vrshrn_n_u16(a, 3);
  // CHECK: rshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

uint16x4_t test_vrshrn_n_u32(uint32x4_t a) {
  // CHECK: test_vrshrn_n_u32
  return vrshrn_n_u32(a, 9);
  // CHECK: rshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

uint32x2_t test_vrshrn_n_u64(uint64x2_t a) {
  // CHECK: test_vrshrn_n_u64
  return vrshrn_n_u64(a, 19);
  // CHECK: rshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

int8x16_t test_vrshrn_high_n_s16(int8x8_t a, int16x8_t b) {
  // CHECK: test_vrshrn_high_n_s16
  return vrshrn_high_n_s16(a, b, 3);
  // CHECK: rshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

int16x8_t test_vrshrn_high_n_s32(int16x4_t a, int32x4_t b) {
  // CHECK: test_vrshrn_high_n_s32
  return vrshrn_high_n_s32(a, b, 9);
  // CHECK: rshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

int32x4_t test_vrshrn_high_n_s64(int32x2_t a, int64x2_t b) {
  // CHECK: test_vrshrn_high_n_s64
  return vrshrn_high_n_s64(a, b, 19);
  // CHECK: rshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

uint8x16_t test_vrshrn_high_n_u16(uint8x8_t a, uint16x8_t b) {
  // CHECK: test_vrshrn_high_n_u16
  return vrshrn_high_n_u16(a, b, 3);
  // CHECK: rshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

uint16x8_t test_vrshrn_high_n_u32(uint16x4_t a, uint32x4_t b) {
  // CHECK: test_vrshrn_high_n_u32
  return vrshrn_high_n_u32(a, b, 9);
  // CHECK: rshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

uint32x4_t test_vrshrn_high_n_u64(uint32x2_t a, uint64x2_t b) {
  // CHECK: test_vrshrn_high_n_u64
  return vrshrn_high_n_u64(a, b, 19);
  // CHECK: rshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

int8x8_t test_vqrshrun_n_s16(int16x8_t a) {
  // CHECK: test_vqrshrun_n_s16
  return vqrshrun_n_s16(a, 3);
  // CHECK: sqrshrun {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

int16x4_t test_vqrshrun_n_s32(int32x4_t a) {
  // CHECK: test_vqrshrun_n_s32
  return vqrshrun_n_s32(a, 9);
  // CHECK: sqrshrun {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

int32x2_t test_vqrshrun_n_s64(int64x2_t a) {
  // CHECK: test_vqrshrun_n_s64
  return vqrshrun_n_s64(a, 19);
  // CHECK: sqrshrun {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

int8x16_t test_vqrshrun_high_n_s16(int8x8_t a, int16x8_t b) {
  // CHECK: test_vqrshrun_high_n_s16
  return vqrshrun_high_n_s16(a, b, 3);
  // CHECK: sqrshrun2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

int16x8_t test_vqrshrun_high_n_s32(int16x4_t a, int32x4_t b) {
  // CHECK: test_vqrshrun_high_n_s32
  return vqrshrun_high_n_s32(a, b, 9);
  // CHECK: sqrshrun2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

int32x4_t test_vqrshrun_high_n_s64(int32x2_t a, int64x2_t b) {
  // CHECK: test_vqrshrun_high_n_s64
  return vqrshrun_high_n_s64(a, b, 19);
  // CHECK: sqrshrun2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

int8x8_t test_vqshrn_n_s16(int16x8_t a) {
  // CHECK: test_vqshrn_n_s16
  return vqshrn_n_s16(a, 3);
  // CHECK: sqshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

int16x4_t test_vqshrn_n_s32(int32x4_t a) {
  // CHECK: test_vqshrn_n_s32
  return vqshrn_n_s32(a, 9);
  // CHECK: sqshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

int32x2_t test_vqshrn_n_s64(int64x2_t a) {
  // CHECK: test_vqshrn_n_s64
  return vqshrn_n_s64(a, 19);
  // CHECK: sqshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

uint8x8_t test_vqshrn_n_u16(uint16x8_t a) {
  // CHECK: test_vqshrn_n_u16
  return vqshrn_n_u16(a, 3);
  // CHECK: uqshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

uint16x4_t test_vqshrn_n_u32(uint32x4_t a) {
  // CHECK: test_vqshrn_n_u32
  return vqshrn_n_u32(a, 9);
  // CHECK: uqshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

uint32x2_t test_vqshrn_n_u64(uint64x2_t a) {
  // CHECK: test_vqshrn_n_u64
  return vqshrn_n_u64(a, 19);
  // CHECK: uqshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

int8x16_t test_vqshrn_high_n_s16(int8x8_t a, int16x8_t b) {
  // CHECK: test_vqshrn_high_n_s16
  return vqshrn_high_n_s16(a, b, 3);
  // CHECK: sqshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

int16x8_t test_vqshrn_high_n_s32(int16x4_t a, int32x4_t b) {
  // CHECK: test_vqshrn_high_n_s32
  return vqshrn_high_n_s32(a, b, 9);
  // CHECK: sqshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

int32x4_t test_vqshrn_high_n_s64(int32x2_t a, int64x2_t b) {
  // CHECK: test_vqshrn_high_n_s64
  return vqshrn_high_n_s64(a, b, 19);
  // CHECK: sqshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

uint8x16_t test_vqshrn_high_n_u16(uint8x8_t a, uint16x8_t b) {
  // CHECK: test_vqshrn_high_n_u16
  return vqshrn_high_n_u16(a, b, 3);
  // CHECK: uqshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

uint16x8_t test_vqshrn_high_n_u32(uint16x4_t a, uint32x4_t b) {
  // CHECK: test_vqshrn_high_n_u32
  return vqshrn_high_n_u32(a, b, 9);
  // CHECK: uqshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

uint32x4_t test_vqshrn_high_n_u64(uint32x2_t a, uint64x2_t b) {
  // CHECK: test_vqshrn_high_n_u64
  return vqshrn_high_n_u64(a, b, 19);
  // CHECK: uqshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

int8x8_t test_vqrshrn_n_s16(int16x8_t a) {
  // CHECK: test_vqrshrn_n_s16
  return vqrshrn_n_s16(a, 3);
  // CHECK: sqrshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

int16x4_t test_vqrshrn_n_s32(int32x4_t a) {
  // CHECK: test_vqrshrn_n_s32
  return vqrshrn_n_s32(a, 9);
  // CHECK: sqrshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

int32x2_t test_vqrshrn_n_s64(int64x2_t a) {
  // CHECK: test_vqrshrn_n_s64
  return vqrshrn_n_s64(a, 19);
  // CHECK: sqrshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

uint8x8_t test_vqrshrn_n_u16(uint16x8_t a) {
  // CHECK: test_vqrshrn_n_u16
  return vqrshrn_n_u16(a, 3);
  // CHECK: uqrshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
}

uint16x4_t test_vqrshrn_n_u32(uint32x4_t a) {
  // CHECK: test_vqrshrn_n_u32
  return vqrshrn_n_u32(a, 9);
  // CHECK: uqrshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
}

uint32x2_t test_vqrshrn_n_u64(uint64x2_t a) {
  // CHECK: test_vqrshrn_n_u64
  return vqrshrn_n_u64(a, 19);
  // CHECK: uqrshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
}

int8x16_t test_vqrshrn_high_n_s16(int8x8_t a, int16x8_t b) {
  // CHECK: test_vqrshrn_high_n_s16
  return vqrshrn_high_n_s16(a, b, 3);
  // CHECK: sqrshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

int16x8_t test_vqrshrn_high_n_s32(int16x4_t a, int32x4_t b) {
  // CHECK: test_vqrshrn_high_n_s32
  return vqrshrn_high_n_s32(a, b, 9);
  // CHECK: sqrshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

int32x4_t test_vqrshrn_high_n_s64(int32x2_t a, int64x2_t b) {
  // CHECK: test_vqrshrn_high_n_s64
  return vqrshrn_high_n_s64(a, b, 19);
  // CHECK: sqrshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

uint8x16_t test_vqrshrn_high_n_u16(uint8x8_t a, uint16x8_t b) {
  // CHECK: test_vqrshrn_high_n_u16
  return vqrshrn_high_n_u16(a, b, 3);
  // CHECK: uqrshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
}

uint16x8_t test_vqrshrn_high_n_u32(uint16x4_t a, uint32x4_t b) {
  // CHECK: test_vqrshrn_high_n_u32
  return vqrshrn_high_n_u32(a, b, 9);
  // CHECK: uqrshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
}

uint32x4_t test_vqrshrn_high_n_u64(uint32x2_t a, uint64x2_t b) {
  // CHECK: test_vqrshrn_high_n_u64
  return vqrshrn_high_n_u64(a, b, 19);
  // CHECK: uqrshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
}

int16x8_t test_vshll_n_s8(int8x8_t a) {
// CHECK: test_vshll_n_s8
  return vshll_n_s8(a, 3);
// CHECK: sshll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #3
}

int32x4_t test_vshll_n_s16(int16x4_t a) {
// CHECK: test_vshll_n_s16
  return vshll_n_s16(a, 9);
// CHECK: sshll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #9
}

int64x2_t test_vshll_n_s32(int32x2_t a) {
// CHECK: test_vshll_n_s32
  return vshll_n_s32(a, 19);
// CHECK: sshll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #19
}

uint16x8_t test_vshll_n_u8(uint8x8_t a) {
// CHECK: test_vshll_n_u8
  return vshll_n_u8(a, 3);
// CHECK: ushll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #3
}

uint32x4_t test_vshll_n_u16(uint16x4_t a) {
// CHECK: test_vshll_n_u16
  return vshll_n_u16(a, 9);
// CHECK: ushll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #9
}

uint64x2_t test_vshll_n_u32(uint32x2_t a) {
// CHECK: test_vshll_n_u32
  return vshll_n_u32(a, 19);
// CHECK: ushll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #19
}

int16x8_t test_vshll_high_n_s8(int8x16_t a) {
// CHECK: test_vshll_high_n_s8
  return vshll_high_n_s8(a, 3);
// CHECK: sshll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #3
}

int32x4_t test_vshll_high_n_s16(int16x8_t a) {
// CHECK: test_vshll_high_n_s16
  return vshll_high_n_s16(a, 9);
// CHECK: sshll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #9
}

int64x2_t test_vshll_high_n_s32(int32x4_t a) {
// CHECK: test_vshll_high_n_s32
  return vshll_high_n_s32(a, 19);
// CHECK: sshll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #19
}

uint16x8_t test_vshll_high_n_u8(uint8x16_t a) {
// CHECK: test_vshll_high_n_u8
  return vshll_high_n_u8(a, 3);
// CHECK: ushll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #3
}

uint32x4_t test_vshll_high_n_u16(uint16x8_t a) {
// CHECK: test_vshll_high_n_u16
  return vshll_high_n_u16(a, 9);
// CHECK: ushll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #9
}

uint64x2_t test_vshll_high_n_u32(uint32x4_t a) {
// CHECK: test_vshll_high_n_u32
  return vshll_high_n_u32(a, 19);
// CHECK: ushll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #19
}

int16x8_t test_vmovl_s8(int8x8_t a) {
// CHECK: test_vmovl_s8
  return vmovl_s8(a);
// CHECK: sshll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #0
}

int32x4_t test_vmovl_s16(int16x4_t a) {
// CHECK: test_vmovl_s16
  return vmovl_s16(a);
// CHECK: sshll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #0
}

int64x2_t test_vmovl_s32(int32x2_t a) {
// CHECK: test_vmovl_s32
  return vmovl_s32(a);
// CHECK: sshll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #0
}

uint16x8_t test_vmovl_u8(uint8x8_t a) {
// CHECK: test_vmovl_u8
  return vmovl_u8(a);
// CHECK: ushll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #0
}

uint32x4_t test_vmovl_u16(uint16x4_t a) {
// CHECK: test_vmovl_u16
  return vmovl_u16(a);
// CHECK: ushll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #0
}

uint64x2_t test_vmovl_u32(uint32x2_t a) {
// CHECK: test_vmovl_u32
  return vmovl_u32(a);
// CHECK: ushll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #0
}

int16x8_t test_vmovl_high_s8(int8x16_t a) {
// CHECK: test_vmovl_high_s8
  return vmovl_high_s8(a);
// CHECK: sshll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #0
}

int32x4_t test_vmovl_high_s16(int16x8_t a) {
// CHECK: test_vmovl_high_s16
  return vmovl_high_s16(a);
// CHECK: sshll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #0
}

int64x2_t test_vmovl_high_s32(int32x4_t a) {
// CHECK: test_vmovl_high_s32
  return vmovl_high_s32(a);
// CHECK: sshll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #0
}

uint16x8_t test_vmovl_high_u8(uint8x16_t a) {
// CHECK: test_vmovl_high_u8
  return vmovl_high_u8(a);
// CHECK: ushll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #0
}

uint32x4_t test_vmovl_high_u16(uint16x8_t a) {
// CHECK: test_vmovl_high_u16
  return vmovl_high_u16(a);
// CHECK: ushll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #0
}

uint64x2_t test_vmovl_high_u32(uint32x4_t a) {
// CHECK: test_vmovl_high_u32
  return vmovl_high_u32(a);
// CHECK: ushll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #0
}

float32x2_t test_vcvt_n_f32_s32(int32x2_t a) {
  // CHECK: test_vcvt_n_f32_s32
  return vcvt_n_f32_s32(a, 31);
  // CHECK: scvtf {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
}

float32x4_t test_vcvtq_n_f32_s32(int32x4_t a) {
  // CHECK: test_vcvtq_n_f32_s32
  return vcvtq_n_f32_s32(a, 31);
  // CHECK: scvtf {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
}

float64x2_t test_vcvtq_n_f64_s64(int64x2_t a) {
  // CHECK: test_vcvtq_n_f64_s64
  return vcvtq_n_f64_s64(a, 50);
  // CHECK: scvtf {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50
}

float32x2_t test_vcvt_n_f32_u32(uint32x2_t a) {
  // CHECK: test_vcvt_n_f32_u32
  return vcvt_n_f32_u32(a, 31);
  // CHECK: ucvtf {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
}

float32x4_t test_vcvtq_n_f32_u32(uint32x4_t a) {
  // CHECK: test_vcvtq_n_f32_u32
  return vcvtq_n_f32_u32(a, 31);
  // CHECK: ucvtf {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
}

float64x2_t test_vcvtq_n_f64_u64(uint64x2_t a) {
  // CHECK: test_vcvtq_n_f64_u64
  return vcvtq_n_f64_u64(a, 50);
  // CHECK: ucvtf {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50
}

int32x2_t test_vcvt_n_s32_f32(float32x2_t a) {
  // CHECK: test_vcvt_n_s32_f32
  return vcvt_n_s32_f32(a, 31);
  // CHECK: fcvtzs {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
}

int32x4_t test_vcvtq_n_s32_f32(float32x4_t a) {
  // CHECK: test_vcvtq_n_s32_f32
  return vcvtq_n_s32_f32(a, 31);
  // CHECK: fcvtzs {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
}

int64x2_t test_vcvtq_n_s64_f64(float64x2_t a) {
  // CHECK: test_vcvtq_n_s64_f64
  return vcvtq_n_s64_f64(a, 50);
  // CHECK: fcvtzs {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50
}

uint32x2_t test_vcvt_n_u32_f32(float32x2_t a) {
  // CHECK: test_vcvt_n_u32_f32
  return vcvt_n_u32_f32(a, 31);
  // CHECK: fcvtzu {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
}

uint32x4_t test_vcvtq_n_u32_f32(float32x4_t a) {
  // CHECK: test_vcvt_n_u32_f32
  return vcvtq_n_u32_f32(a, 31);
  // CHECK: fcvtzu {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
}

uint64x2_t test_vcvtq_n_u64_f64(float64x2_t a) {
  // CHECK: test_vcvtq_n_u64_f64
  return vcvtq_n_u64_f64(a, 50);
  // CHECK: fcvtzu {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50
}

int16x8_t test_vaddl_s8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vaddl_s8
  return vaddl_s8(a, b);
  // CHECK: saddl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}

int32x4_t test_vaddl_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vaddl_s16
  return vaddl_s16(a, b);
  // CHECK: saddl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}

int64x2_t test_vaddl_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vaddl_s32
  return vaddl_s32(a, b);
  // CHECK: saddl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

uint16x8_t test_vaddl_u8(uint8x8_t a, uint8x8_t b) {
  // CHECK: test_vaddl_u8
  return vaddl_u8(a, b);
  // CHECK: uaddl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}

uint32x4_t test_vaddl_u16(uint16x4_t a, uint16x4_t b) {
  // CHECK: test_vaddl_u16
  return vaddl_u16(a, b);
  // CHECK: uaddl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}

uint64x2_t test_vaddl_u32(uint32x2_t a, uint32x2_t b) {
  // CHECK: test_vaddl_u32
  return vaddl_u32(a, b);
  // CHECK: uaddl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int16x8_t test_vaddl_high_s8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vaddl_high_s8
  return vaddl_high_s8(a, b);
  // CHECK: saddl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}

int32x4_t test_vaddl_high_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vaddl_high_s16
  return vaddl_high_s16(a, b);
  // CHECK: saddl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int64x2_t test_vaddl_high_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vaddl_high_s32
  return vaddl_high_s32(a, b);
  // CHECK: saddl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint16x8_t test_vaddl_high_u8(uint8x16_t a, uint8x16_t b) {
  // CHECK: test_vaddl_high_u8
  return vaddl_high_u8(a, b);
  // CHECK: uaddl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}

uint32x4_t test_vaddl_high_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vaddl_high_u16
  return vaddl_high_u16(a, b);
  // CHECK: uaddl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint64x2_t test_vaddl_high_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vaddl_high_u32
  return vaddl_high_u32(a, b);
  // CHECK: uaddl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int16x8_t test_vaddw_s8(int16x8_t a, int8x8_t b) {
  // CHECK: test_vaddw_s8
  return vaddw_s8(a, b);
  // CHECK: saddw {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.8b
}

int32x4_t test_vaddw_s16(int32x4_t a, int16x4_t b) {
  // CHECK: test_vaddw_s16
  return vaddw_s16(a, b);
  // CHECK: saddw {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.4h
}

int64x2_t test_vaddw_s32(int64x2_t a, int32x2_t b) {
  // CHECK: test_vaddw_s32
  return vaddw_s32(a, b);
  // CHECK: saddw {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.2s
}

uint16x8_t test_vaddw_u8(uint16x8_t a, uint8x8_t b) {
  // CHECK: test_vaddw_u8
  return vaddw_u8(a, b);
  // CHECK: uaddw {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.8b
}

uint32x4_t test_vaddw_u16(uint32x4_t a, uint16x4_t b) {
  // CHECK: test_vaddw_u16
  return vaddw_u16(a, b);
  // CHECK: uaddw {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.4h
}

uint64x2_t test_vaddw_u32(uint64x2_t a, uint32x2_t b) {
  // CHECK: test_vaddw_u32
  return vaddw_u32(a, b);
  // CHECK: uaddw {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.2s
}

int16x8_t test_vaddw_high_s8(int16x8_t a, int8x16_t b) {
  // CHECK: test_vaddw_high_s8
  return vaddw_high_s8(a, b);
  // CHECK: saddw2 {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.16b
}

int32x4_t test_vaddw_high_s16(int32x4_t a, int16x8_t b) {
  // CHECK: test_vaddw_high_s16
  return vaddw_high_s16(a, b);
  // CHECK: saddw2 {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.8h
}

int64x2_t test_vaddw_high_s32(int64x2_t a, int32x4_t b) {
  // CHECK: test_vaddw_high_s32
  return vaddw_high_s32(a, b);
  // CHECK: saddw2 {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.4s
}

uint16x8_t test_vaddw_high_u8(uint16x8_t a, uint8x16_t b) {
  // CHECK: test_vaddw_high_u8
  return vaddw_high_u8(a, b);
  // CHECK: uaddw2 {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.16b
}

uint32x4_t test_vaddw_high_u16(uint32x4_t a, uint16x8_t b) {
  // CHECK: test_vaddw_high_u16
  return vaddw_high_u16(a, b);
  // CHECK: uaddw2 {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.8h
}

uint64x2_t test_vaddw_high_u32(uint64x2_t a, uint32x4_t b) {
  // CHECK: test_vaddw_high_u32
  return vaddw_high_u32(a, b);
  // CHECK: uaddw2 {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.4s
}

int16x8_t test_vsubl_s8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vsubl_s8
  return vsubl_s8(a, b);
  // CHECK: ssubl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}

int32x4_t test_vsubl_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vsubl_s16
  return vsubl_s16(a, b);
  // CHECK: ssubl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}

int64x2_t test_vsubl_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vsubl_s32
  return vsubl_s32(a, b);
  // CHECK: ssubl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

uint16x8_t test_vsubl_u8(uint8x8_t a, uint8x8_t b) {
  // CHECK: test_vsubl_u8
  return vsubl_u8(a, b);
  // CHECK: usubl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}

uint32x4_t test_vsubl_u16(uint16x4_t a, uint16x4_t b) {
  // CHECK: test_vsubl_u16
  return vsubl_u16(a, b);
  // CHECK: usubl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}

uint64x2_t test_vsubl_u32(uint32x2_t a, uint32x2_t b) {
  // CHECK: test_vsubl_u32
  return vsubl_u32(a, b);
  // CHECK: usubl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int16x8_t test_vsubl_high_s8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vsubl_high_s8
  return vsubl_high_s8(a, b);
  // CHECK: ssubl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}

int32x4_t test_vsubl_high_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vsubl_high_s16
  return vsubl_high_s16(a, b);
  // CHECK: ssubl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int64x2_t test_vsubl_high_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vsubl_high_s32
  return vsubl_high_s32(a, b);
  // CHECK: ssubl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint16x8_t test_vsubl_high_u8(uint8x16_t a, uint8x16_t b) {
  // CHECK: test_vsubl_high_u8
  return vsubl_high_u8(a, b);
  // CHECK: usubl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}

uint32x4_t test_vsubl_high_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vsubl_high_u16
  return vsubl_high_u16(a, b);
  // CHECK: usubl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint64x2_t test_vsubl_high_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vsubl_high_u32
  return vsubl_high_u32(a, b);
  // CHECK: usubl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int16x8_t test_vsubw_s8(int16x8_t a, int8x8_t b) {
  // CHECK: test_vsubw_s8
  return vsubw_s8(a, b);
  // CHECK: ssubw {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.8b
}

int32x4_t test_vsubw_s16(int32x4_t a, int16x4_t b) {
  // CHECK: test_vsubw_s16
  return vsubw_s16(a, b);
  // CHECK: ssubw {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.4h
}

int64x2_t test_vsubw_s32(int64x2_t a, int32x2_t b) {
  // CHECK: test_vsubw_s32
  return vsubw_s32(a, b);
  // CHECK: ssubw {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.2s
}

uint16x8_t test_vsubw_u8(uint16x8_t a, uint8x8_t b) {
  // CHECK: test_vsubw_u8
  return vsubw_u8(a, b);
  // CHECK: usubw {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.8b
}

uint32x4_t test_vsubw_u16(uint32x4_t a, uint16x4_t b) {
  // CHECK: test_vsubw_u16
  return vsubw_u16(a, b);
  // CHECK: usubw {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.4h
}

uint64x2_t test_vsubw_u32(uint64x2_t a, uint32x2_t b) {
  // CHECK: test_vsubw_u32
  return vsubw_u32(a, b);
  // CHECK: usubw {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.2s
}

int16x8_t test_vsubw_high_s8(int16x8_t a, int8x16_t b) {
  // CHECK: test_vsubw_high_s8
  return vsubw_high_s8(a, b);
  // CHECK: ssubw2 {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.16b
}

int32x4_t test_vsubw_high_s16(int32x4_t a, int16x8_t b) {
  // CHECK: test_vsubw_high_s16
  return vsubw_high_s16(a, b);
  // CHECK: ssubw2 {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.8h
}

int64x2_t test_vsubw_high_s32(int64x2_t a, int32x4_t b) {
  // CHECK: test_vsubw_high_s32
  return vsubw_high_s32(a, b);
  // CHECK: ssubw2 {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.4s
}

uint16x8_t test_vsubw_high_u8(uint16x8_t a, uint8x16_t b) {
  // CHECK: test_vsubw_high_u8
  return vsubw_high_u8(a, b);
  // CHECK: usubw2 {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.16b
}

uint32x4_t test_vsubw_high_u16(uint32x4_t a, uint16x8_t b) {
  // CHECK: test_vsubw_high_u16
  return vsubw_high_u16(a, b);
  // CHECK: usubw2 {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.8h
}

uint64x2_t test_vsubw_high_u32(uint64x2_t a, uint32x4_t b) {
  // CHECK: test_vsubw_high_u32
  return vsubw_high_u32(a, b);
  // CHECK: usubw2 {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.4s
}

int8x8_t test_vaddhn_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vaddhn_s16
  return vaddhn_s16(a, b);
  // CHECK: addhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int16x4_t test_vaddhn_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vaddhn_s32
  return vaddhn_s32(a, b);
  // CHECK: addhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x2_t test_vaddhn_s64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vaddhn_s64
  return vaddhn_s64(a, b);
  // CHECK: addhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

uint8x8_t test_vaddhn_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vaddhn_u16
  return vaddhn_u16(a, b);
  // CHECK: addhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint16x4_t test_vaddhn_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vaddhn_u32
  return vaddhn_u32(a, b);
  // CHECK: addhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint32x2_t test_vaddhn_u64(uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vaddhn_u64
  return vaddhn_u64(a, b);
  // CHECK: addhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

int8x16_t test_vaddhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) {
  // CHECK: test_vaddhn_high_s16
  return vaddhn_high_s16(r, a, b);
  // CHECK: addhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int16x8_t test_vaddhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) {
  // CHECK: test_vaddhn_high_s32
  return vaddhn_high_s32(r, a, b);
  // CHECK: addhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x4_t test_vaddhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) {
  // CHECK: test_vaddhn_high_s64
  return vaddhn_high_s64(r, a, b);
  // CHECK: addhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

uint8x16_t test_vaddhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vaddhn_high_u16
  return vaddhn_high_u16(r, a, b);
  // CHECK: addhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint16x8_t test_vaddhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vaddhn_high_u32
  return vaddhn_high_u32(r, a, b);
  // CHECK: addhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint32x4_t test_vaddhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vaddhn_high_u64
  return vaddhn_high_u64(r, a, b);
  // CHECK: addhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

int8x8_t test_vraddhn_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vraddhn_s16
  return vraddhn_s16(a, b);
  // CHECK: raddhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int16x4_t test_vraddhn_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vraddhn_s32
  return vraddhn_s32(a, b);
  // CHECK: raddhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x2_t test_vraddhn_s64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vraddhn_s64
  return vraddhn_s64(a, b);
  // CHECK: raddhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

uint8x8_t test_vraddhn_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vraddhn_u16
  return vraddhn_u16(a, b);
  // CHECK: raddhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint16x4_t test_vraddhn_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vraddhn_u32
  return vraddhn_u32(a, b);
  // CHECK: raddhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint32x2_t test_vraddhn_u64(uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vraddhn_u64
  return vraddhn_u64(a, b);
  // CHECK: raddhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

int8x16_t test_vraddhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) {
  // CHECK: test_vraddhn_high_s16
  return vraddhn_high_s16(r, a, b);
  // CHECK: raddhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int16x8_t test_vraddhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) {
  // CHECK: test_vraddhn_high_s32
  return vraddhn_high_s32(r, a, b);
  // CHECK: raddhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x4_t test_vraddhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) {
  // CHECK: test_vraddhn_high_s64
  return vraddhn_high_s64(r, a, b);
  // CHECK: raddhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

uint8x16_t test_vraddhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vraddhn_high_u16
  return vraddhn_high_u16(r, a, b);
  // CHECK: raddhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint16x8_t test_vraddhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vraddhn_high_u32
  return vraddhn_high_u32(r, a, b);
  // CHECK: raddhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint32x4_t test_vraddhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vraddhn_high_u64
  return vraddhn_high_u64(r, a, b);
  // CHECK: raddhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

int8x8_t test_vsubhn_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vsubhn_s16
  return vsubhn_s16(a, b);
  // CHECK: subhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int16x4_t test_vsubhn_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vsubhn_s32
  return vsubhn_s32(a, b);
  // CHECK: subhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x2_t test_vsubhn_s64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vsubhn_s64
  return vsubhn_s64(a, b);
  // CHECK: subhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

uint8x8_t test_vsubhn_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vsubhn_u16
  return vsubhn_u16(a, b);
  // CHECK: subhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint16x4_t test_vsubhn_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vsubhn_u32
  return vsubhn_u32(a, b);
  // CHECK: subhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint32x2_t test_vsubhn_u64(uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vsubhn_u64
  return vsubhn_u64(a, b);
  // CHECK: subhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

int8x16_t test_vsubhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) {
  // CHECK: test_vsubhn_high_s16
  return vsubhn_high_s16(r, a, b);
  // CHECK: subhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int16x8_t test_vsubhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) {
  // CHECK: test_vsubhn_high_s32
  return vsubhn_high_s32(r, a, b);
  // CHECK: subhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x4_t test_vsubhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) {
  // CHECK: test_vsubhn_high_s64
  return vsubhn_high_s64(r, a, b);
  // CHECK: subhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

uint8x16_t test_vsubhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vsubhn_high_u16
  return vsubhn_high_u16(r, a, b);
  // CHECK: subhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint16x8_t test_vsubhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vsubhn_high_u32
  return vsubhn_high_u32(r, a, b);
  // CHECK: subhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint32x4_t test_vsubhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vsubhn_high_u64
  return vsubhn_high_u64(r, a, b);
  // CHECK: subhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

int8x8_t test_vrsubhn_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vrsubhn_s16
  return vrsubhn_s16(a, b);
  // CHECK: rsubhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int16x4_t test_vrsubhn_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vrsubhn_s32
  return vrsubhn_s32(a, b);
  // CHECK: rsubhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x2_t test_vrsubhn_s64(int64x2_t a, int64x2_t b) {
  // CHECK: test_vrsubhn_s64
  return vrsubhn_s64(a, b);
  // CHECK: rsubhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

uint8x8_t test_vrsubhn_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vrsubhn_u16
  return vrsubhn_u16(a, b);
  // CHECK: rsubhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint16x4_t test_vrsubhn_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vrsubhn_u32
  return vrsubhn_u32(a, b);
  // CHECK: rsubhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint32x2_t test_vrsubhn_u64(uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vrsubhn_u64
  return vrsubhn_u64(a, b);
  // CHECK: rsubhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

int8x16_t test_vrsubhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) {
  // CHECK: test_vrsubhn_high_s16
  return vrsubhn_high_s16(r, a, b);
  // CHECK: rsubhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int16x8_t test_vrsubhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) {
  // CHECK: test_vrsubhn_high_s32
  return vrsubhn_high_s32(r, a, b);
  // CHECK: rsubhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x4_t test_vrsubhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) {
  // CHECK: test_vrsubhn_high_s64
  return vrsubhn_high_s64(r, a, b);
  // CHECK: rsubhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

uint8x16_t test_vrsubhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vrsubhn_high_u16
  return vrsubhn_high_u16(r, a, b);
  // CHECK: rsubhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

uint16x8_t test_vrsubhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vrsubhn_high_u32
  return vrsubhn_high_u32(r, a, b);
  // CHECK: rsubhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

uint32x4_t test_vrsubhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) {
  // CHECK: test_vrsubhn_high_u64
  return vrsubhn_high_u64(r, a, b);
  // CHECK: rsubhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d
}

int16x8_t test_vabdl_s8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vabdl_s8
  return vabdl_s8(a, b);
  // CHECK: sabdl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
int32x4_t test_vabdl_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vabdl_s16
  return vabdl_s16(a, b);
  // CHECK: sabdl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
int64x2_t test_vabdl_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vabdl_s32
  return vabdl_s32(a, b);
  // CHECK: sabdl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}
uint16x8_t test_vabdl_u8(uint8x8_t a, uint8x8_t b) {
  // CHECK: test_vabdl_u8
  return vabdl_u8(a, b);
  // CHECK: uabdl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
uint32x4_t test_vabdl_u16(uint16x4_t a, uint16x4_t b) {
  // CHECK: test_vabdl_u16
  return vabdl_u16(a, b);
  // CHECK: uabdl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
uint64x2_t test_vabdl_u32(uint32x2_t a, uint32x2_t b) {
  // CHECK: test_vabdl_u32
  return vabdl_u32(a, b);
  // CHECK: uabdl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int16x8_t test_vabal_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
  // CHECK: test_vabal_s8
  return vabal_s8(a, b, c);
  // CHECK: sabal {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
int32x4_t test_vabal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
  // CHECK: test_vabal_s16
  return vabal_s16(a, b, c);
  // CHECK: sabal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
int64x2_t test_vabal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
  // CHECK: test_vabal_s32
  return vabal_s32(a, b, c);
  // CHECK: sabal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}
uint16x8_t test_vabal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
  // CHECK: test_vabal_u8
  return vabal_u8(a, b, c);
  // CHECK: uabal {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
uint32x4_t test_vabal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
  // CHECK: test_vabal_u16
  return vabal_u16(a, b, c);
  // CHECK: uabal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
uint64x2_t test_vabal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
  // CHECK: test_vabal_u32
  return vabal_u32(a, b, c);
  // CHECK: uabal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int16x8_t test_vabdl_high_s8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vabdl_high_s8
  return vabdl_high_s8(a, b);
  // CHECK: sabdl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
int32x4_t test_vabdl_high_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vabdl_high_s16
  return vabdl_high_s16(a, b);
  // CHECK: sabdl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
int64x2_t test_vabdl_high_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vabdl_high_s32
  return vabdl_high_s32(a, b);
  // CHECK: sabdl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}
uint16x8_t test_vabdl_high_u8(uint8x16_t a, uint8x16_t b) {
  // CHECK: test_vabdl_high_u8
  return vabdl_high_u8(a, b);
  // CHECK: uabdl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
uint32x4_t test_vabdl_high_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vabdl_high_u16
  return vabdl_high_u16(a, b);
  // CHECK: uabdl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
uint64x2_t test_vabdl_high_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vabdl_high_u32
  return vabdl_high_u32(a, b);
  // CHECK: uabdl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int16x8_t test_vabal_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) {
  // CHECK: test_vabal_high_s8
  return vabal_high_s8(a, b, c);
  // CHECK: sabal2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
int32x4_t test_vabal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
  // CHECK: test_vabal_high_s16
  return vabal_high_s16(a, b, c);
  // CHECK: sabal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
int64x2_t test_vabal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
  // CHECK: test_vabal_high_s32
  return vabal_high_s32(a, b, c);
  // CHECK: sabal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}
uint16x8_t test_vabal_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) {
  // CHECK: test_vabal_high_u8
  return vabal_high_u8(a, b, c);
  // CHECK: uabal2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
uint32x4_t test_vabal_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) {
  // CHECK: test_vabal_high_u16
  return vabal_high_u16(a, b, c);
  // CHECK: uabal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
uint64x2_t test_vabal_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) {
  // CHECK: test_vabal_high_u32
  return vabal_high_u32(a, b, c);
  // CHECK: uabal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int16x8_t test_vmull_s8(int8x8_t a, int8x8_t b) {
  // CHECK: test_vmull_s8
  return vmull_s8(a, b);
  // CHECK: smull {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
int32x4_t test_vmull_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vmull_s16
  return vmull_s16(a, b);
  // CHECK: smull {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
int64x2_t test_vmull_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vmull_s32
  return vmull_s32(a, b);
  // CHECK: smull {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}
uint16x8_t test_vmull_u8(uint8x8_t a, uint8x8_t b) {
  // CHECK: test_vmull_u8
  return vmull_u8(a, b);
  // CHECK: umull {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
uint32x4_t test_vmull_u16(uint16x4_t a, uint16x4_t b) {
  // CHECK: test_vmull_u16
  return vmull_u16(a, b);
  // CHECK: umull {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
uint64x2_t test_vmull_u32(uint32x2_t a, uint32x2_t b) {
  // CHECK: test_vmull_u32
  return vmull_u32(a, b);
  // CHECK: umull {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int16x8_t test_vmull_high_s8(int8x16_t a, int8x16_t b) {
  // CHECK: test_vmull_high_s8
  return vmull_high_s8(a, b);
  // CHECK: smull2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
int32x4_t test_vmull_high_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vmull_high_s16
  return vmull_high_s16(a, b);
  // CHECK: smull2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
int64x2_t test_vmull_high_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vmull_high_s32
  return vmull_high_s32(a, b);
  // CHECK: smull2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}
uint16x8_t test_vmull_high_u8(uint8x16_t a, uint8x16_t b) {
  // CHECK: test_vmull_high_u8
  return vmull_high_u8(a, b);
  // CHECK: umull2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
uint32x4_t test_vmull_high_u16(uint16x8_t a, uint16x8_t b) {
  // CHECK: test_vmull_high_u16
  return vmull_high_u16(a, b);
  // CHECK: umull2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
uint64x2_t test_vmull_high_u32(uint32x4_t a, uint32x4_t b) {
  // CHECK: test_vmull_high_u32
  return vmull_high_u32(a, b);
  // CHECK: umull2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int16x8_t test_vmlal_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
  // CHECK: test_vmlal_s8
  return vmlal_s8(a, b, c);
  // CHECK: smlal {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
int32x4_t test_vmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
  // CHECK: test_vmlal_s16
  return vmlal_s16(a, b, c);
  // CHECK: smlal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
int64x2_t test_vmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
  // CHECK: test_vmlal_s32
  return vmlal_s32(a, b, c);
  // CHECK: smlal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}
uint16x8_t test_vmlal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
  // CHECK: test_vmlal_u8
  return vmlal_u8(a, b, c);
  // CHECK: umlal {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
uint32x4_t test_vmlal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
  // CHECK: test_vmlal_u16
  return vmlal_u16(a, b, c);
  // CHECK: umlal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
uint64x2_t test_vmlal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
  // CHECK: test_vmlal_u32
  return vmlal_u32(a, b, c);
  // CHECK: umlal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int16x8_t test_vmlal_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) {
  // CHECK: test_vmlal_high_s8
  return vmlal_high_s8(a, b, c);
  // CHECK: smlal2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
int32x4_t test_vmlal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
  // CHECK: test_vmlal_high_s16
  return vmlal_high_s16(a, b, c);
  // CHECK: smlal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
int64x2_t test_vmlal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
  // CHECK: test_vmlal_high_s32
  return vmlal_high_s32(a, b, c);
  // CHECK: smlal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}
uint16x8_t test_vmlal_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) {
  // CHECK: test_vmlal_high_u8
  return vmlal_high_u8(a, b, c);
  // CHECK: umlal2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
uint32x4_t test_vmlal_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) {
  // CHECK: test_vmlal_high_u16
  return vmlal_high_u16(a, b, c);
  // CHECK: umlal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
uint64x2_t test_vmlal_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) {
  // CHECK: test_vmlal_high_u32
  return vmlal_high_u32(a, b, c);
  // CHECK: umlal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int16x8_t test_vmlsl_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
  // CHECK: test_vmlsl_s8
  return vmlsl_s8(a, b, c);
  // CHECK: smlsl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
int32x4_t test_vmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
  // CHECK: test_vmlsl_s16
  return vmlsl_s16(a, b, c);
  // CHECK: smlsl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
int64x2_t test_vmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
  // CHECK: test_vmlsl_s32
  return vmlsl_s32(a, b, c);
  // CHECK: smlsl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}
uint16x8_t test_vmlsl_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
  // CHECK: test_vmlsl_u8
  return vmlsl_u8(a, b, c);
  // CHECK: umlsl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}
uint32x4_t test_vmlsl_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
  // CHECK: test_vmlsl_u16
  return vmlsl_u16(a, b, c);
  // CHECK: umlsl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
uint64x2_t test_vmlsl_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
  // CHECK: test_vmlsl_u32
  return vmlsl_u32(a, b, c);
  // CHECK: umlsl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int16x8_t test_vmlsl_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) {
  // CHECK: test_vmlsl_high_s8
  return vmlsl_high_s8(a, b, c);
  // CHECK: smlsl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
int32x4_t test_vmlsl_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
  // CHECK: test_vmlsl_high_s16
  return vmlsl_high_s16(a, b, c);
  // CHECK: smlsl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
int64x2_t test_vmlsl_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
  // CHECK: test_vmlsl_high_s32
  return vmlsl_high_s32(a, b, c);
  // CHECK: smlsl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}
uint16x8_t test_vmlsl_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) {
  // CHECK: test_vmlsl_high_u8
  return vmlsl_high_u8(a, b, c);
  // CHECK: umlsl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}
uint32x4_t test_vmlsl_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) {
  // CHECK: test_vmlsl_high_u16
  return vmlsl_high_u16(a, b, c);
  // CHECK: umlsl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
uint64x2_t test_vmlsl_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) {
  // CHECK: test_vmlsl_high_u32
  return vmlsl_high_u32(a, b, c);
  // CHECK: umlsl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x4_t test_vqdmull_s16(int16x4_t a, int16x4_t b) {
  // CHECK: test_vqdmull_s16
  return vqdmull_s16(a, b);
  // CHECK: sqdmull {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}
int64x2_t test_vqdmull_s32(int32x2_t a, int32x2_t b) {
  // CHECK: test_vqdmull_s32
  return vqdmull_s32(a, b);
  // CHECK: sqdmull {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int32x4_t test_vqdmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
  // CHECK: test_vqdmlal_s16
  return vqdmlal_s16(a, b, c);
  // CHECK: sqdmlal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}

int64x2_t test_vqdmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
  // CHECK: test_vqdmlal_s32
  return vqdmlal_s32(a, b, c);
  // CHECK: sqdmlal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int32x4_t test_vqdmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
  // CHECK: test_vqdmlsl_s16
  return vqdmlsl_s16(a, b, c);
  // CHECK: sqdmlsl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h
}

int64x2_t test_vqdmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
  // CHECK: test_vqdmlsl_s32
  return vqdmlsl_s32(a, b, c);
  // CHECK: sqdmlsl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s
}

int32x4_t test_vqdmull_high_s16(int16x8_t a, int16x8_t b) {
  // CHECK: test_vqdmull_high_s16
  return vqdmull_high_s16(a, b);
  // CHECK: sqdmull2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}
int64x2_t test_vqdmull_high_s32(int32x4_t a, int32x4_t b) {
  // CHECK: test_vqdmull_high_s32
  return vqdmull_high_s32(a, b);
  // CHECK: sqdmull2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x4_t test_vqdmlal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
  // CHECK: test_vqdmlal_high_s16
  return vqdmlal_high_s16(a, b, c);
  // CHECK: sqdmlal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int64x2_t test_vqdmlal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
  // CHECK: test_vqdmlal_high_s32
  return vqdmlal_high_s32(a, b, c);
  // CHECK: sqdmlal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

int32x4_t test_vqdmlsl_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
  // CHECK: test_vqdmlsl_high_s16
  return vqdmlsl_high_s16(a, b, c);
  // CHECK: sqdmlsl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h
}

int64x2_t test_vqdmlsl_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
  // CHECK: test_vqdmlsl_high_s32
  return vqdmlsl_high_s32(a, b, c);
  // CHECK: sqdmlsl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s
}

poly16x8_t test_vmull_p8(poly8x8_t a, poly8x8_t b) {
  // CHECK: test_vmull_p8
  return vmull_p8(a, b);
  // CHECK: pmull {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b
}

poly16x8_t test_vmull_high_p8(poly8x16_t a, poly8x16_t b) {
  // CHECK: test_vmull_high_p8
  return vmull_high_p8(a, b);
  // CHECK: pmull2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b
}

int64_t test_vaddd_s64(int64_t a, int64_t b) {
// CHECK: test_vaddd_s64
  return vaddd_s64(a, b);
// CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint64_t test_vaddd_u64(uint64_t a, uint64_t b) {
// CHECK: test_vaddd_u64
  return vaddd_u64(a, b);
// CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int64_t test_vsubd_s64(int64_t a, int64_t b) {
// CHECK: test_vsubd_s64
  return vsubd_s64(a, b);
// CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint64_t test_vsubd_u64(uint64_t a, uint64_t b) {
// CHECK: test_vsubd_u64
  return vsubd_u64(a, b);
// CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8_t test_vqaddb_s8(int8_t a, int8_t b) {
// CHECK: test_vqaddb_s8
  return vqaddb_s8(a, b);
// CHECK: sqadd {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
}

int16_t test_vqaddh_s16(int16_t a, int16_t b) {
// CHECK: test_vqaddh_s16
  return vqaddh_s16(a, b);
// CHECK: sqadd {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

int32_t test_vqadds_s32(int32_t a, int32_t b) {
// CHECK: test_vqadds_s32
  return vqadds_s32(a, b);
// CHECK: sqadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

int64_t test_vqaddd_s64(int64_t a, int64_t b) {
// CHECK: test_vqaddd_s64
  return vqaddd_s64(a, b);
// CHECK: sqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint8_t test_vqaddb_u8(uint8_t a, uint8_t b) {
// CHECK: test_vqaddb_u8
  return vqaddb_u8(a, b);
// CHECK: uqadd {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
}

uint16_t test_vqaddh_u16(uint16_t a, uint16_t b) {
// CHECK: test_vqaddh_u16
  return vqaddh_u16(a, b);
// CHECK: uqadd {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

uint32_t test_vqadds_u32(uint32_t a, uint32_t b) {
// CHECK: test_vqadds_u32
  return vqadds_u32(a, b);
// CHECK: uqadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

uint64_t test_vqaddd_u64(uint64_t a, uint64_t b) {
// CHECK: test_vqaddd_u64
  return vqaddd_u64(a, b);
// CHECK: uqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int8_t test_vqsubb_s8(int8_t a, int8_t b) {
// CHECK: test_vqsubb_s8
  return vqsubb_s8(a, b);
// CHECK: sqsub {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
}

int16_t test_vqsubh_s16(int16_t a, int16_t b) {
// CHECK: test_vqsubh_s16
  return vqsubh_s16(a, b);
// CHECK: sqsub {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

int32_t test_vqsubs_s32(int32_t a, int32_t b) {
  // CHECK: test_vqsubs_s32
  return vqsubs_s32(a, b);
// CHECK: sqsub {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

int64_t test_vqsubd_s64(int64_t a, int64_t b) {
// CHECK: test_vqsubd_s64
  return vqsubd_s64(a, b);
// CHECK: sqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint8_t test_vqsubb_u8(uint8_t a, uint8_t b) {
// CHECK: test_vqsubb_u8
  return vqsubb_u8(a, b);
// CHECK: uqsub {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
}

uint16_t test_vqsubh_u16(uint16_t a, uint16_t b) {
// CHECK: test_vqsubh_u16
  return vqsubh_u16(a, b);
// CHECK: uqsub {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

uint32_t test_vqsubs_u32(uint32_t a, uint32_t b) {
// CHECK: test_vqsubs_u32
  return vqsubs_u32(a, b);
// CHECK: uqsub {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

uint64_t test_vqsubd_u64(uint64_t a, uint64_t b) {
// CHECK: test_vqsubd_u64
  return vqsubd_u64(a, b);
// CHECK: uqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

int64_t test_vshld_s64(int64_t a, int64_t b) {
// CHECK: test_vshld_s64
  return vshld_s64(a, b);
// CHECK: sshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

uint64_t test_vshld_u64(uint64_t a, uint64_t b) {
// CHECK: test_vshld_u64
  return vshld_u64(a, b);
// CHECK: ushl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

// CHECK: test_vqshlb_s8
int8_t test_vqshlb_s8(int8_t a, int8_t b) {
  return vqshlb_s8(a, b);
// CHECK: sqshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
}

// CHECK: test_vqshlh_s16
int16_t test_vqshlh_s16(int16_t a, int16_t b) {
  return vqshlh_s16(a, b);
// CHECK: sqshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

// CHECK: test_vqshls_s32
int32_t test_vqshls_s32(int32_t a, int32_t b) {
  return vqshls_s32(a, b);
// CHECK: sqshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

// CHECK: test_vqshld_s64
int64_t test_vqshld_s64(int64_t a, int64_t b) {
  return vqshld_s64(a, b);
// CHECK: sqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

// CHECK: test_vqshlb_u8
uint8_t test_vqshlb_u8(uint8_t a, uint8_t b) {
  return vqshlb_u8(a, b);
// CHECK: uqshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
}

// CHECK: test_vqshlh_u16
uint16_t test_vqshlh_u16(uint16_t a, uint16_t b) {
  return vqshlh_u16(a, b);
// CHECK: uqshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

// CHECK: test_vqshls_u32
uint32_t test_vqshls_u32(uint32_t a, uint32_t b) {
  return vqshls_u32(a, b);
// CHECK: uqshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

// CHECK: test_vqshld_u64
uint64_t test_vqshld_u64(uint64_t a, uint64_t b) {
  return vqshld_u64(a, b);
// CHECK: uqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

// CHECK: test_vrshld_s64
int64_t test_vrshld_s64(int64_t a, int64_t b) {
  return vrshld_s64(a, b);
// CHECK: srshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}


// CHECK: test_vrshld_u64
uint64_t test_vrshld_u64(uint64_t a, uint64_t b) {
  return vrshld_u64(a, b);
// CHECK: urshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

// CHECK: test_vqrshlb_s8
int8_t test_vqrshlb_s8(int8_t a, int8_t b) {
  return vqrshlb_s8(a, b);
// CHECK: sqrshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
}

// CHECK: test_vqrshlh_s16
int16_t test_vqrshlh_s16(int16_t a, int16_t b) {
  return vqrshlh_s16(a, b);
// CHECK: sqrshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

// CHECK: test_vqrshls_s32
int32_t test_vqrshls_s32(int32_t a, int32_t b) {
  return vqrshls_s32(a, b);
// CHECK: sqrshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

// CHECK: test_vqrshld_s64
int64_t test_vqrshld_s64(int64_t a, int64_t b) {
  return vqrshld_s64(a, b);
// CHECK: sqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

// CHECK: test_vqrshlb_u8
uint8_t test_vqrshlb_u8(uint8_t a, uint8_t b) {
  return vqrshlb_u8(a, b);
// CHECK: uqrshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
}

// CHECK: test_vqrshlh_u16
uint16_t test_vqrshlh_u16(uint16_t a, uint16_t b) {
  return vqrshlh_u16(a, b);
// CHECK: uqrshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

// CHECK: test_vqrshls_u32
uint32_t test_vqrshls_u32(uint32_t a, uint32_t b) {
  return vqrshls_u32(a, b);
// CHECK: uqrshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

// CHECK: test_vqrshld_u64
uint64_t test_vqrshld_u64(uint64_t a, uint64_t b) {
  return vqrshld_u64(a, b);
// CHECK: uqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

// CHECK: test_vpaddd_s64
int64_t test_vpaddd_s64(int64x2_t a) {
  return vpaddd_s64(a);
// CHECK: addp {{d[0-9]+}}, {{v[0-9]+}}.2d
}

// CHECK: test_vpadds_f32
float32_t test_vpadds_f32(float32x2_t a) {
  return vpadds_f32(a);
// CHECK: faddp {{s[0-9]+}}, {{v[0-9]+}}.2s
}

// CHECK: test_vpaddd_f64
float64_t test_vpaddd_f64(float64x2_t a) {
  return vpaddd_f64(a);
// CHECK: faddp {{d[0-9]+}}, {{v[0-9]+}}.2d
}

// CHECK: test_vpmaxnms_f32
float32_t test_vpmaxnms_f32(float32x2_t a) {
  return vpmaxnms_f32(a);
// CHECK: fmaxnmp {{s[0-9]+}}, {{v[0-9]+}}.2s
}

// CHECK: test_vpmaxnmqd_f64
float64_t test_vpmaxnmqd_f64(float64x2_t a) {
  return vpmaxnmqd_f64(a);
// CHECK: fmaxnmp {{d[0-9]+}}, {{v[0-9]+}}.2d
}

// CHECK: test_vpmaxs_f32
float32_t test_vpmaxs_f32(float32x2_t a) {
  return vpmaxs_f32(a);
// CHECK: fmaxp {{s[0-9]+}}, {{v[0-9]+}}.2s
}

// CHECK: test_vpmaxqd_f64
float64_t test_vpmaxqd_f64(float64x2_t a) {
  return vpmaxqd_f64(a);
// CHECK: fmaxp {{d[0-9]+}}, {{v[0-9]+}}.2d
}

// CHECK: test_vpminnms_f32
float32_t test_vpminnms_f32(float32x2_t a) {
  return vpminnms_f32(a);
// CHECK: fminnmp {{s[0-9]+}}, {{v[0-9]+}}.2s
}

// CHECK: test_vpminnmqd_f64
float64_t test_vpminnmqd_f64(float64x2_t a) {
  return vpminnmqd_f64(a);
// CHECK: fminnmp {{d[0-9]+}}, {{v[0-9]+}}.2d
}

// CHECK: test_vpmins_f32
float32_t test_vpmins_f32(float32x2_t a) {
  return vpmins_f32(a);
// CHECK: fminp {{s[0-9]+}}, {{v[0-9]+}}.2s
}

// CHECK: test_vpminqd_f64
float64_t test_vpminqd_f64(float64x2_t a) {
  return vpminqd_f64(a);
// CHECK: fminp {{d[0-9]+}}, {{v[0-9]+}}.2d
}

int16_t test_vqdmulhh_s16(int16_t a, int16_t b) {
// CHECK: test_vqdmulhh_s16
  return vqdmulhh_s16(a, b);
// CHECK: sqdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

int32_t test_vqdmulhs_s32(int32_t a, int32_t b) {
// CHECK: test_vqdmulhs_s32
  return vqdmulhs_s32(a, b);
// CHECK: sqdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

int16_t test_vqrdmulhh_s16(int16_t a, int16_t b) {
// CHECK: test_vqrdmulhh_s16
  return vqrdmulhh_s16(a, b);
// CHECK: sqrdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
}

int32_t test_vqrdmulhs_s32(int32_t a, int32_t b) {
// CHECK: test_vqrdmulhs_s32
  return vqrdmulhs_s32(a, b);
// CHECK: sqrdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

float32_t test_vmulxs_f32(float32_t a, float32_t b) {
// CHECK: test_vmulxs_f32
  return vmulxs_f32(a, b);
// CHECK: fmulx {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

float64_t test_vmulxd_f64(float64_t a, float64_t b) {
// CHECK: test_vmulxd_f64
  return vmulxd_f64(a, b);
// CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

float32_t test_vrecpss_f32(float32_t a, float32_t b) {
// CHECK: test_vrecpss_f32
  return vrecpss_f32(a, b);
// CHECK: frecps {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

float64_t test_vrecpsd_f64(float64_t a, float64_t b) {
// CHECK: test_vrecpsd_f64
  return vrecpsd_f64(a, b);
// CHECK: frecps {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

float32_t test_vrsqrtss_f32(float32_t a, float32_t b) {
// CHECK: test_vrsqrtss_f32
  return vrsqrtss_f32(a, b);
// CHECK: frsqrts {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
}

float64_t test_vrsqrtsd_f64(float64_t a, float64_t b) {
// CHECK: test_vrsqrtsd_f64
  return vrsqrtsd_f64(a, b);
// CHECK: frsqrts {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
}

float32_t test_vcvts_f32_s32(int32_t a) {
// CHECK: test_vcvts_f32_s32
// CHECK: scvtf {{s[0-9]+}}, {{s[0-9]+}}
  return (float32_t)vcvts_f32_s32(a);
}

float64_t test_vcvtd_f64_s64(int64_t a) {
// CHECK: test_vcvtd_f64_s64
// CHECK: scvtf {{d[0-9]+}}, {{d[0-9]+}}
  return (float64_t)vcvtd_f64_s64(a);
}

float32_t test_vcvts_f32_u32(uint32_t a) {
// CHECK: test_vcvts_f32_u32
// CHECK: ucvtf {{s[0-9]+}}, {{s[0-9]+}}
  return (float32_t)vcvts_f32_u32(a);
}

float64_t test_vcvtd_f64_u64(uint64_t a) {
// CHECK: test_vcvtd_f64_u64
// CHECK: ucvtf {{d[0-9]+}}, {{d[0-9]+}}
  return (float64_t)vcvtd_f64_u64(a);
}

float32_t test_vrecpes_f32(float32_t a) {
// CHECK: test_vrecpes_f32
// CHECK: frecpe {{s[0-9]+}}, {{s[0-9]+}}
  return vrecpes_f32(a);
}
 
float64_t test_vrecped_f64(float64_t a) {
// CHECK: test_vrecped_f64
// CHECK: frecpe {{d[0-9]+}}, {{d[0-9]+}}
  return vrecped_f64(a);
}
 
float32_t test_vrecpxs_f32(float32_t a) {
// CHECK: test_vrecpxs_f32
// CHECK: frecpx {{s[0-9]+}}, {{s[0-9]+}}
  return vrecpxs_f32(a);
 }
 
float64_t test_vrecpxd_f64(float64_t a) {
// CHECK: test_vrecpxd_f64
// CHECK: frecpx {{d[0-9]+}}, {{d[0-9]+}}
  return vrecpxd_f64(a);
}

float32_t test_vrsqrtes_f32(float32_t a) {
// CHECK: vrsqrtes_f32
// CHECK: frsqrte {{s[0-9]+}}, {{s[0-9]+}}
  return vrsqrtes_f32(a);
}

float64_t test_vrsqrted_f64(float64_t a) {
// CHECK: vrsqrted_f64
// CHECK: frsqrte {{d[0-9]+}}, {{d[0-9]+}}
  return vrsqrted_f64(a);
}

uint8x16_t test_vld1q_u8(uint8_t const *a) {
  // CHECK: test_vld1q_u8
  return vld1q_u8(a);
  // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

uint16x8_t test_vld1q_u16(uint16_t const *a) {
  // CHECK: test_vld1q_u16
  return vld1q_u16(a);
  // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

uint32x4_t test_vld1q_u32(uint32_t const *a) {
  // CHECK: test_vld1q_u32
  return vld1q_u32(a);
  // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

uint64x2_t test_vld1q_u64(uint64_t const *a) {
  // CHECK: test_vld1q_u64
  return vld1q_u64(a);
  // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

int8x16_t test_vld1q_s8(int8_t const *a) {
  // CHECK: test_vld1q_s8
  return vld1q_s8(a);
  // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

int16x8_t test_vld1q_s16(int16_t const *a) {
  // CHECK: test_vld1q_s16
  return vld1q_s16(a);
  // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

int32x4_t test_vld1q_s32(int32_t const *a) {
  // CHECK: test_vld1q_s32
  return vld1q_s32(a);
  // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

int64x2_t test_vld1q_s64(int64_t const *a) {
  // CHECK: test_vld1q_s64
  return vld1q_s64(a);
  // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

float16x8_t test_vld1q_f16(float16_t const *a) {
  // CHECK: test_vld1q_f16
  return vld1q_f16(a);
  // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

float32x4_t test_vld1q_f32(float32_t const *a) {
  // CHECK: test_vld1q_f32
  return vld1q_f32(a);
  // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

float64x2_t test_vld1q_f64(float64_t const *a) {
  // CHECK: test_vld1q_f64
  return vld1q_f64(a);
  // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

poly8x16_t test_vld1q_p8(poly8_t const *a) {
  // CHECK: test_vld1q_p8
  return vld1q_p8(a);
  // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

poly16x8_t test_vld1q_p16(poly16_t const *a) {
  // CHECK: test_vld1q_p16
  return vld1q_p16(a);
  // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

uint8x8_t test_vld1_u8(uint8_t const *a) {
  // CHECK: test_vld1_u8
  return vld1_u8(a);
  // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

uint16x4_t test_vld1_u16(uint16_t const *a) {
  // CHECK: test_vld1_u16
  return vld1_u16(a);
  // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

uint32x2_t test_vld1_u32(uint32_t const *a) {
  // CHECK: test_vld1_u32
  return vld1_u32(a);
  // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

uint64x1_t test_vld1_u64(uint64_t const *a) {
  // CHECK: test_vld1_u64
  return vld1_u64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

int8x8_t test_vld1_s8(int8_t const *a) {
  // CHECK: test_vld1_s8
  return vld1_s8(a);
  // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

int16x4_t test_vld1_s16(int16_t const *a) {
  // CHECK: test_vld1_s16
  return vld1_s16(a);
  // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

int32x2_t test_vld1_s32(int32_t const *a) {
  // CHECK: test_vld1_s32
  return vld1_s32(a);
  // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

int64x1_t test_vld1_s64(int64_t const *a) {
  // CHECK: test_vld1_s64
  return vld1_s64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

float16x4_t test_vld1_f16(float16_t const *a) {
  // CHECK: test_vld1_f16
  return vld1_f16(a);
  // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

float32x2_t test_vld1_f32(float32_t const *a) {
  // CHECK: test_vld1_f32
  return vld1_f32(a);
  // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

float64x1_t test_vld1_f64(float64_t const *a) {
  // CHECK: test_vld1_f64
  return vld1_f64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

poly8x8_t test_vld1_p8(poly8_t const *a) {
  // CHECK: test_vld1_p8
  return vld1_p8(a);
  // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

poly16x4_t test_vld1_p16(poly16_t const *a) {
  // CHECK: test_vld1_p16
  return vld1_p16(a);
  // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

uint8x16x2_t test_vld2q_u8(uint8_t const *a) {
  // CHECK: test_vld2q_u8
  return vld2q_u8(a);
  // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

uint16x8x2_t test_vld2q_u16(uint16_t const *a) {
  // CHECK: test_vld2q_u16
  return vld2q_u16(a);
  // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

uint32x4x2_t test_vld2q_u32(uint32_t const *a) {
  // CHECK: test_vld2q_u32
  return vld2q_u32(a);
  // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

uint64x2x2_t test_vld2q_u64(uint64_t const *a) {
  // CHECK: test_vld2q_u64
  return vld2q_u64(a);
  // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

int8x16x2_t test_vld2q_s8(int8_t const *a) {
  // CHECK: test_vld2q_s8
  return vld2q_s8(a);
  // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

int16x8x2_t test_vld2q_s16(int16_t const *a) {
  // CHECK: test_vld2q_s16
  return vld2q_s16(a);
  // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

int32x4x2_t test_vld2q_s32(int32_t const *a) {
  // CHECK: test_vld2q_s32
  return vld2q_s32(a);
  // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

int64x2x2_t test_vld2q_s64(int64_t const *a) {
  // CHECK: test_vld2q_s64
  return vld2q_s64(a);
  // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

float16x8x2_t test_vld2q_f16(float16_t const *a) {
  // CHECK: test_vld2q_f16
  return vld2q_f16(a);
  // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

float32x4x2_t test_vld2q_f32(float32_t const *a) {
  // CHECK: test_vld2q_f32
  return vld2q_f32(a);
  // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

float64x2x2_t test_vld2q_f64(float64_t const *a) {
  // CHECK: test_vld2q_f64
  return vld2q_f64(a);
  // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

poly8x16x2_t test_vld2q_p8(poly8_t const *a) {
  // CHECK: test_vld2q_p8
  return vld2q_p8(a);
  // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

poly16x8x2_t test_vld2q_p16(poly16_t const *a) {
  // CHECK: test_vld2q_p16
  return vld2q_p16(a);
  // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

uint8x8x2_t test_vld2_u8(uint8_t const *a) {
  // CHECK: test_vld2_u8
  return vld2_u8(a);
  // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

uint16x4x2_t test_vld2_u16(uint16_t const *a) {
  // CHECK: test_vld2_u16
  return vld2_u16(a);
  // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

uint32x2x2_t test_vld2_u32(uint32_t const *a) {
  // CHECK: test_vld2_u32
  return vld2_u32(a);
  // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

uint64x1x2_t test_vld2_u64(uint64_t const *a) {
  // CHECK: test_vld2_u64
  return vld2_u64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

int8x8x2_t test_vld2_s8(int8_t const *a) {
  // CHECK: test_vld2_s8
  return vld2_s8(a);
  // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

int16x4x2_t test_vld2_s16(int16_t const *a) {
  // CHECK: test_vld2_s16
  return vld2_s16(a);
  // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

int32x2x2_t test_vld2_s32(int32_t const *a) {
  // CHECK: test_vld2_s32
  return vld2_s32(a);
  // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

int64x1x2_t test_vld2_s64(int64_t const *a) {
  // CHECK: test_vld2_s64
  return vld2_s64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

float16x4x2_t test_vld2_f16(float16_t const *a) {
  // CHECK: test_vld2_f16
  return vld2_f16(a);
  // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

float32x2x2_t test_vld2_f32(float32_t const *a) {
  // CHECK: test_vld2_f32
  return vld2_f32(a);
  // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

float64x1x2_t test_vld2_f64(float64_t const *a) {
  // CHECK: test_vld2_f64
  return vld2_f64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

poly8x8x2_t test_vld2_p8(poly8_t const *a) {
  // CHECK: test_vld2_p8
  return vld2_p8(a);
  // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

poly16x4x2_t test_vld2_p16(poly16_t const *a) {
  // CHECK: test_vld2_p16
  return vld2_p16(a);
  // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

uint8x16x3_t test_vld3q_u8(uint8_t const *a) {
  // CHECK: test_vld3q_u8
  return vld3q_u8(a);
  // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
  // [{{x[0-9]+|sp}}]
}

uint16x8x3_t test_vld3q_u16(uint16_t const *a) {
  // CHECK: test_vld3q_u16
  return vld3q_u16(a);
  // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
  // [{{x[0-9]+|sp}}]
}

uint32x4x3_t test_vld3q_u32(uint32_t const *a) {
  // CHECK: test_vld3q_u32
  return vld3q_u32(a);
  // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
  // [{{x[0-9]+|sp}}]
}

uint64x2x3_t test_vld3q_u64(uint64_t const *a) {
  // CHECK: test_vld3q_u64
  return vld3q_u64(a);
  // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
  // [{{x[0-9]+|sp}}]
}

int8x16x3_t test_vld3q_s8(int8_t const *a) {
  // CHECK: test_vld3q_s8
  return vld3q_s8(a);
  // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
  // [{{x[0-9]+|sp}}]
}

int16x8x3_t test_vld3q_s16(int16_t const *a) {
  // CHECK: test_vld3q_s16
  return vld3q_s16(a);
  // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
  // [{{x[0-9]+|sp}}]
}

int32x4x3_t test_vld3q_s32(int32_t const *a) {
  // CHECK: test_vld3q_s32
  return vld3q_s32(a);
  // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
  // [{{x[0-9]+|sp}}]
}

int64x2x3_t test_vld3q_s64(int64_t const *a) {
  // CHECK: test_vld3q_s64
  return vld3q_s64(a);
  // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
  // [{{x[0-9]+|sp}}]
}

float16x8x3_t test_vld3q_f16(float16_t const *a) {
  // CHECK: test_vld3q_f16
  return vld3q_f16(a);
  // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
  // [{{x[0-9]+|sp}}]
}

float32x4x3_t test_vld3q_f32(float32_t const *a) {
  // CHECK: test_vld3q_f32
  return vld3q_f32(a);
  // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
  // [{{x[0-9]+|sp}}]
}

float64x2x3_t test_vld3q_f64(float64_t const *a) {
  // CHECK: test_vld3q_f64
  return vld3q_f64(a);
  // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
  // [{{x[0-9]+|sp}}]
}

poly8x16x3_t test_vld3q_p8(poly8_t const *a) {
  // CHECK: test_vld3q_p8
  return vld3q_p8(a);
  // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
  // [{{x[0-9]+|sp}}]
}

poly16x8x3_t test_vld3q_p16(poly16_t const *a) {
  // CHECK: test_vld3q_p16
  return vld3q_p16(a);
  // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
  // [{{x[0-9]+|sp}}]
}

uint8x8x3_t test_vld3_u8(uint8_t const *a) {
  // CHECK: test_vld3_u8
  return vld3_u8(a);
  // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
  // [{{x[0-9]+|sp}}]
}

uint16x4x3_t test_vld3_u16(uint16_t const *a) {
  // CHECK: test_vld3_u16
  return vld3_u16(a);
  // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
  // [{{x[0-9]+|sp}}]
}

uint32x2x3_t test_vld3_u32(uint32_t const *a) {
  // CHECK: test_vld3_u32
  return vld3_u32(a);
  // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
  // [{{x[0-9]+|sp}}]
}

uint64x1x3_t test_vld3_u64(uint64_t const *a) {
  // CHECK: test_vld3_u64
  return vld3_u64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
  // [{{x[0-9]+|sp}}]
}

int8x8x3_t test_vld3_s8(int8_t const *a) {
  // CHECK: test_vld3_s8
  return vld3_s8(a);
  // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
  // [{{x[0-9]+|sp}}]
}

int16x4x3_t test_vld3_s16(int16_t const *a) {
  // CHECK: test_vld3_s16
  return vld3_s16(a);
  // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
  // [{{x[0-9]+|sp}}]
}

int32x2x3_t test_vld3_s32(int32_t const *a) {
  // CHECK: test_vld3_s32
  return vld3_s32(a);
  // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
  // [{{x[0-9]+|sp}}]
}

int64x1x3_t test_vld3_s64(int64_t const *a) {
  // CHECK: test_vld3_s64
  return vld3_s64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
  // [{{x[0-9]+|sp}}]
}

float16x4x3_t test_vld3_f16(float16_t const *a) {
  // CHECK: test_vld3_f16
  return vld3_f16(a);
  // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
  // [{{x[0-9]+|sp}}]
}

float32x2x3_t test_vld3_f32(float32_t const *a) {
  // CHECK: test_vld3_f32
  return vld3_f32(a);
  // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
  // [{{x[0-9]+|sp}}]
}

float64x1x3_t test_vld3_f64(float64_t const *a) {
  // CHECK: test_vld3_f64
  return vld3_f64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
  // [{{x[0-9]+|sp}}]
}

poly8x8x3_t test_vld3_p8(poly8_t const *a) {
  // CHECK: test_vld3_p8
  return vld3_p8(a);
  // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
  // [{{x[0-9]+|sp}}]
}

poly16x4x3_t test_vld3_p16(poly16_t const *a) {
  // CHECK: test_vld3_p16
  return vld3_p16(a);
  // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
  // [{{x[0-9]+|sp}}]
}

uint8x16x4_t test_vld4q_u8(uint8_t const *a) {
  // CHECK: test_vld4q_u8
  return vld4q_u8(a);
  // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
  // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

uint16x8x4_t test_vld4q_u16(uint16_t const *a) {
  // CHECK: test_vld4q_u16
  return vld4q_u16(a);
  // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
  // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

uint32x4x4_t test_vld4q_u32(uint32_t const *a) {
  // CHECK: test_vld4q_u32
  return vld4q_u32(a);
  // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
  // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

uint64x2x4_t test_vld4q_u64(uint64_t const *a) {
  // CHECK: test_vld4q_u64
  return vld4q_u64(a);
  // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
  // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

int8x16x4_t test_vld4q_s8(int8_t const *a) {
  // CHECK: test_vld4q_s8
  return vld4q_s8(a);
  // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
  // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

int16x8x4_t test_vld4q_s16(int16_t const *a) {
  // CHECK: test_vld4q_s16
  return vld4q_s16(a);
  // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
  // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

int32x4x4_t test_vld4q_s32(int32_t const *a) {
  // CHECK: test_vld4q_s32
  return vld4q_s32(a);
  // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
  // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

int64x2x4_t test_vld4q_s64(int64_t const *a) {
  // CHECK: test_vld4q_s64
  return vld4q_s64(a);
  // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
  // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

float16x8x4_t test_vld4q_f16(float16_t const *a) {
  // CHECK: test_vld4q_f16
  return vld4q_f16(a);
  // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
  // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

float32x4x4_t test_vld4q_f32(float32_t const *a) {
  // CHECK: test_vld4q_f32
  return vld4q_f32(a);
  // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
  // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

float64x2x4_t test_vld4q_f64(float64_t const *a) {
  // CHECK: test_vld4q_f64
  return vld4q_f64(a);
  // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
  // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

poly8x16x4_t test_vld4q_p8(poly8_t const *a) {
  // CHECK: test_vld4q_p8
  return vld4q_p8(a);
  // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
  // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

poly16x8x4_t test_vld4q_p16(poly16_t const *a) {
  // CHECK: test_vld4q_p16
  return vld4q_p16(a);
  // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
  // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

uint8x8x4_t test_vld4_u8(uint8_t const *a) {
  // CHECK: test_vld4_u8
  return vld4_u8(a);
  // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
  // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

uint16x4x4_t test_vld4_u16(uint16_t const *a) {
  // CHECK: test_vld4_u16
  return vld4_u16(a);
  // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
  // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

uint32x2x4_t test_vld4_u32(uint32_t const *a) {
  // CHECK: test_vld4_u32
  return vld4_u32(a);
  // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
  // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

uint64x1x4_t test_vld4_u64(uint64_t const *a) {
  // CHECK: test_vld4_u64
  return vld4_u64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
  // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

int8x8x4_t test_vld4_s8(int8_t const *a) {
  // CHECK: test_vld4_s8
  return vld4_s8(a);
  // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
  // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

int16x4x4_t test_vld4_s16(int16_t const *a) {
  // CHECK: test_vld4_s16
  return vld4_s16(a);
  // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
  // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

int32x2x4_t test_vld4_s32(int32_t const *a) {
  // CHECK: test_vld4_s32
  return vld4_s32(a);
  // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
  // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

int64x1x4_t test_vld4_s64(int64_t const *a) {
  // CHECK: test_vld4_s64
  return vld4_s64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
  // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

float16x4x4_t test_vld4_f16(float16_t const *a) {
  // CHECK: test_vld4_f16
  return vld4_f16(a);
  // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
  // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

float32x2x4_t test_vld4_f32(float32_t const *a) {
  // CHECK: test_vld4_f32
  return vld4_f32(a);
  // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
  // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

float64x1x4_t test_vld4_f64(float64_t const *a) {
  // CHECK: test_vld4_f64
  return vld4_f64(a);
  // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
  // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

poly8x8x4_t test_vld4_p8(poly8_t const *a) {
  // CHECK: test_vld4_p8
  return vld4_p8(a);
  // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
  // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

poly16x4x4_t test_vld4_p16(poly16_t const *a) {
  // CHECK: test_vld4_p16
  return vld4_p16(a);
  // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
  // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst1q_u8(uint8_t *a, uint8x16_t b) {
  // CHECK: test_vst1q_u8
  vst1q_u8(a, b);
  // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst1q_u16(uint16_t *a, uint16x8_t b) {
  // CHECK: test_vst1q_u16
  vst1q_u16(a, b);
  // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst1q_u32(uint32_t *a, uint32x4_t b) {
  // CHECK: test_vst1q_u32
  vst1q_u32(a, b);
  // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst1q_u64(uint64_t *a, uint64x2_t b) {
  // CHECK: test_vst1q_u64
  vst1q_u64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst1q_s8(int8_t *a, int8x16_t b) {
  // CHECK: test_vst1q_s8
  vst1q_s8(a, b);
  // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst1q_s16(int16_t *a, int16x8_t b) {
  // CHECK: test_vst1q_s16
  vst1q_s16(a, b);
  // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst1q_s32(int32_t *a, int32x4_t b) {
  // CHECK: test_vst1q_s32
  vst1q_s32(a, b);
  // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst1q_s64(int64_t *a, int64x2_t b) {
  // CHECK: test_vst1q_s64
  vst1q_s64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst1q_f16(float16_t *a, float16x8_t b) {
  // CHECK: test_vst1q_f16
  vst1q_f16(a, b);
  // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst1q_f32(float32_t *a, float32x4_t b) {
  // CHECK: test_vst1q_f32
  vst1q_f32(a, b);
  // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst1q_f64(float64_t *a, float64x2_t b) {
  // CHECK: test_vst1q_f64
  vst1q_f64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst1q_p8(poly8_t *a, poly8x16_t b) {
  // CHECK: test_vst1q_p8
  vst1q_p8(a, b);
  // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst1q_p16(poly16_t *a, poly16x8_t b) {
  // CHECK: test_vst1q_p16
  vst1q_p16(a, b);
  // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst1_u8(uint8_t *a, uint8x8_t b) {
  // CHECK: test_vst1_u8
  vst1_u8(a, b);
  // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst1_u16(uint16_t *a, uint16x4_t b) {
  // CHECK: test_vst1_u16
  vst1_u16(a, b);
  // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst1_u32(uint32_t *a, uint32x2_t b) {
  // CHECK: test_vst1_u32
  vst1_u32(a, b);
  // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst1_u64(uint64_t *a, uint64x1_t b) {
  // CHECK: test_vst1_u64
  vst1_u64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst1_s8(int8_t *a, int8x8_t b) {
  // CHECK: test_vst1_s8
  vst1_s8(a, b);
  // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst1_s16(int16_t *a, int16x4_t b) {
  // CHECK: test_vst1_s16
  vst1_s16(a, b);
  // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst1_s32(int32_t *a, int32x2_t b) {
  // CHECK: test_vst1_s32
  vst1_s32(a, b);
  // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst1_s64(int64_t *a, int64x1_t b) {
  // CHECK: test_vst1_s64
  vst1_s64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst1_f16(float16_t *a, float16x4_t b) {
  // CHECK: test_vst1_f16
  vst1_f16(a, b);
  // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst1_f32(float32_t *a, float32x2_t b) {
  // CHECK: test_vst1_f32
  vst1_f32(a, b);
  // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst1_f64(float64_t *a, float64x1_t b) {
  // CHECK: test_vst1_f64
  vst1_f64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst1_p8(poly8_t *a, poly8x8_t b) {
  // CHECK: test_vst1_p8
  vst1_p8(a, b);
  // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst1_p16(poly16_t *a, poly16x4_t b) {
  // CHECK: test_vst1_p16
  vst1_p16(a, b);
  // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst2q_u8(uint8_t *a, uint8x16x2_t b) {
  // CHECK: test_vst2q_u8
  vst2q_u8(a, b);
  // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst2q_u16(uint16_t *a, uint16x8x2_t b) {
  // CHECK: test_vst2q_u16
  vst2q_u16(a, b);
  // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst2q_u32(uint32_t *a, uint32x4x2_t b) {
  // CHECK: test_vst2q_u32
  vst2q_u32(a, b);
  // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst2q_u64(uint64_t *a, uint64x2x2_t b) {
  // CHECK: test_vst2q_u64
  vst2q_u64(a, b);
  // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst2q_s8(int8_t *a, int8x16x2_t b) {
  // CHECK: test_vst2q_s8
  vst2q_s8(a, b);
  // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst2q_s16(int16_t *a, int16x8x2_t b) {
  // CHECK: test_vst2q_s16
  vst2q_s16(a, b);
  // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst2q_s32(int32_t *a, int32x4x2_t b) {
  // CHECK: test_vst2q_s32
  vst2q_s32(a, b);
  // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst2q_s64(int64_t *a, int64x2x2_t b) {
  // CHECK: test_vst2q_s64
  vst2q_s64(a, b);
  // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst2q_f16(float16_t *a, float16x8x2_t b) {
  // CHECK: test_vst2q_f16
  vst2q_f16(a, b);
  // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst2q_f32(float32_t *a, float32x4x2_t b) {
  // CHECK: test_vst2q_f32
  vst2q_f32(a, b);
  // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst2q_f64(float64_t *a, float64x2x2_t b) {
  // CHECK: test_vst2q_f64
  vst2q_f64(a, b);
  // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst2q_p8(poly8_t *a, poly8x16x2_t b) {
  // CHECK: test_vst2q_p8
  vst2q_p8(a, b);
  // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst2q_p16(poly16_t *a, poly16x8x2_t b) {
  // CHECK: test_vst2q_p16
  vst2q_p16(a, b);
  // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst2_u8(uint8_t *a, uint8x8x2_t b) {
  // CHECK: test_vst2_u8
  vst2_u8(a, b);
  // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst2_u16(uint16_t *a, uint16x4x2_t b) {
  // CHECK: test_vst2_u16
  vst2_u16(a, b);
  // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst2_u32(uint32_t *a, uint32x2x2_t b) {
  // CHECK: test_vst2_u32
  vst2_u32(a, b);
  // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst2_u64(uint64_t *a, uint64x1x2_t b) {
  // CHECK: test_vst2_u64
  vst2_u64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst2_s8(int8_t *a, int8x8x2_t b) {
  // CHECK: test_vst2_s8
  vst2_s8(a, b);
  // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst2_s16(int16_t *a, int16x4x2_t b) {
  // CHECK: test_vst2_s16
  vst2_s16(a, b);
  // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst2_s32(int32_t *a, int32x2x2_t b) {
  // CHECK: test_vst2_s32
  vst2_s32(a, b);
  // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst2_s64(int64_t *a, int64x1x2_t b) {
  // CHECK: test_vst2_s64
  vst2_s64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst2_f16(float16_t *a, float16x4x2_t b) {
  // CHECK: test_vst2_f16
  vst2_f16(a, b);
  // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst2_f32(float32_t *a, float32x2x2_t b) {
  // CHECK: test_vst2_f32
  vst2_f32(a, b);
  // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst2_f64(float64_t *a, float64x1x2_t b) {
  // CHECK: test_vst2_f64
  vst2_f64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst2_p8(poly8_t *a, poly8x8x2_t b) {
  // CHECK: test_vst2_p8
  vst2_p8(a, b);
  // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst2_p16(poly16_t *a, poly16x4x2_t b) {
  // CHECK: test_vst2_p16
  vst2_p16(a, b);
  // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst3q_u8(uint8_t *a, uint8x16x3_t b) {
  // CHECK: test_vst3q_u8
  vst3q_u8(a, b);
  // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_u16(uint16_t *a, uint16x8x3_t b) {
  // CHECK: test_vst3q_u16
  vst3q_u16(a, b);
  // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_u32(uint32_t *a, uint32x4x3_t b) {
  // CHECK: test_vst3q_u32
  vst3q_u32(a, b);
  // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_u64(uint64_t *a, uint64x2x3_t b) {
  // CHECK: test_vst3q_u64
  vst3q_u64(a, b);
  // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_s8(int8_t *a, int8x16x3_t b) {
  // CHECK: test_vst3q_s8
  vst3q_s8(a, b);
  // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_s16(int16_t *a, int16x8x3_t b) {
  // CHECK: test_vst3q_s16
  vst3q_s16(a, b);
  // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_s32(int32_t *a, int32x4x3_t b) {
  // CHECK: test_vst3q_s32
  vst3q_s32(a, b);
  // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_s64(int64_t *a, int64x2x3_t b) {
  // CHECK: test_vst3q_s64
  vst3q_s64(a, b);
  // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_f16(float16_t *a, float16x8x3_t b) {
  // CHECK: test_vst3q_f16
  vst3q_f16(a, b);
  // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_f32(float32_t *a, float32x4x3_t b) {
  // CHECK: test_vst3q_f32
  vst3q_f32(a, b);
  // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_f64(float64_t *a, float64x2x3_t b) {
  // CHECK: test_vst3q_f64
  vst3q_f64(a, b);
  // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_p8(poly8_t *a, poly8x16x3_t b) {
  // CHECK: test_vst3q_p8
  vst3q_p8(a, b);
  // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
  // [{{x[0-9]+|sp}}]
}

void test_vst3q_p16(poly16_t *a, poly16x8x3_t b) {
  // CHECK: test_vst3q_p16
  vst3q_p16(a, b);
  // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_u8(uint8_t *a, uint8x8x3_t b) {
  // CHECK: test_vst3_u8
  vst3_u8(a, b);
  // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_u16(uint16_t *a, uint16x4x3_t b) {
  // CHECK: test_vst3_u16
  vst3_u16(a, b);
  // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_u32(uint32_t *a, uint32x2x3_t b) {
  // CHECK: test_vst3_u32
  vst3_u32(a, b);
  // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_u64(uint64_t *a, uint64x1x3_t b) {
  // CHECK: test_vst3_u64
  vst3_u64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_s8(int8_t *a, int8x8x3_t b) {
  // CHECK: test_vst3_s8
  vst3_s8(a, b);
  // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_s16(int16_t *a, int16x4x3_t b) {
  // CHECK: test_vst3_s16
  vst3_s16(a, b);
  // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_s32(int32_t *a, int32x2x3_t b) {
  // CHECK: test_vst3_s32
  vst3_s32(a, b);
  // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_s64(int64_t *a, int64x1x3_t b) {
  // CHECK: test_vst3_s64
  vst3_s64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_f16(float16_t *a, float16x4x3_t b) {
  // CHECK: test_vst3_f16
  vst3_f16(a, b);
  // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_f32(float32_t *a, float32x2x3_t b) {
  // CHECK: test_vst3_f32
  vst3_f32(a, b);
  // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_f64(float64_t *a, float64x1x3_t b) {
  // CHECK: test_vst3_f64
  vst3_f64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_p8(poly8_t *a, poly8x8x3_t b) {
  // CHECK: test_vst3_p8
  vst3_p8(a, b);
  // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
  // [{{x[0-9]+|sp}}]
}

void test_vst3_p16(poly16_t *a, poly16x4x3_t b) {
  // CHECK: test_vst3_p16
  vst3_p16(a, b);
  // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
  // [{{x[0-9]+|sp}}]
}

void test_vst4q_u8(uint8_t *a, uint8x16x4_t b) {
  // CHECK: test_vst4q_u8
  vst4q_u8(a, b);
  // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
  // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst4q_u16(uint16_t *a, uint16x8x4_t b) {
  // CHECK: test_vst4q_u16
  vst4q_u16(a, b);
  // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
  // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst4q_u32(uint32_t *a, uint32x4x4_t b) {
  // CHECK: test_vst4q_u32
  vst4q_u32(a, b);
  // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
  // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst4q_u64(uint64_t *a, uint64x2x4_t b) {
  // CHECK: test_vst4q_u64
  vst4q_u64(a, b);
  // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
  // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst4q_s8(int8_t *a, int8x16x4_t b) {
  // CHECK: test_vst4q_s8
  vst4q_s8(a, b);
  // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
  // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst4q_s16(int16_t *a, int16x8x4_t b) {
  // CHECK: test_vst4q_s16
  vst4q_s16(a, b);
  // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
  // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst4q_s32(int32_t *a, int32x4x4_t b) {
  // CHECK: test_vst4q_s32
  vst4q_s32(a, b);
  // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
  // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst4q_s64(int64_t *a, int64x2x4_t b) {
  // CHECK: test_vst4q_s64
  vst4q_s64(a, b);
  // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
  // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst4q_f16(float16_t *a, float16x8x4_t b) {
  // CHECK: test_vst4q_f16
  vst4q_f16(a, b);
  // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
  // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst4q_f32(float32_t *a, float32x4x4_t b) {
  // CHECK: test_vst4q_f32
  vst4q_f32(a, b);
  // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
  // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
}

void test_vst4q_f64(float64_t *a, float64x2x4_t b) {
  // CHECK: test_vst4q_f64
  vst4q_f64(a, b);
  // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
  // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
}

void test_vst4q_p8(poly8_t *a, poly8x16x4_t b) {
  // CHECK: test_vst4q_p8
  vst4q_p8(a, b);
  // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
  // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
}

void test_vst4q_p16(poly16_t *a, poly16x8x4_t b) {
  // CHECK: test_vst4q_p16
  vst4q_p16(a, b);
  // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
  // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
}

void test_vst4_u8(uint8_t *a, uint8x8x4_t b) {
  // CHECK: test_vst4_u8
  vst4_u8(a, b);
  // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
  // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst4_u16(uint16_t *a, uint16x4x4_t b) {
  // CHECK: test_vst4_u16
  vst4_u16(a, b);
  // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
  // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst4_u32(uint32_t *a, uint32x2x4_t b) {
  // CHECK: test_vst4_u32
  vst4_u32(a, b);
  // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
  // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst4_u64(uint64_t *a, uint64x1x4_t b) {
  // CHECK: test_vst4_u64
  vst4_u64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
  // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst4_s8(int8_t *a, int8x8x4_t b) {
  // CHECK: test_vst4_s8
  vst4_s8(a, b);
  // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
  // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst4_s16(int16_t *a, int16x4x4_t b) {
  // CHECK: test_vst4_s16
  vst4_s16(a, b);
  // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
  // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst4_s32(int32_t *a, int32x2x4_t b) {
  // CHECK: test_vst4_s32
  vst4_s32(a, b);
  // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
  // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst4_s64(int64_t *a, int64x1x4_t b) {
  // CHECK: test_vst4_s64
  vst4_s64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
  // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst4_f16(float16_t *a, float16x4x4_t b) {
  // CHECK: test_vst4_f16
  vst4_f16(a, b);
  // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
  // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}

void test_vst4_f32(float32_t *a, float32x2x4_t b) {
  // CHECK: test_vst4_f32
  vst4_f32(a, b);
  // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
  // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
}

void test_vst4_f64(float64_t *a, float64x1x4_t b) {
  // CHECK: test_vst4_f64
  vst4_f64(a, b);
  // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
  // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
}

void test_vst4_p8(poly8_t *a, poly8x8x4_t b) {
  // CHECK: test_vst4_p8
  vst4_p8(a, b);
  // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
  // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
}

void test_vst4_p16(poly16_t *a, poly16x4x4_t b) {
  // CHECK: test_vst4_p16
  vst4_p16(a, b);
  // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
  // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
}