/***
*   arm_neon.h - declarations/definitions for ARM NEON specific intrinsics
*
*       Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
*       This include file contains the declarations for ARM NEON intrinsic functions
*
****/

#pragma once

#include <stdint.h>
#include <sal.h>

#if !defined (_M_ARM)
#error This header is specific to ARM targets
#endif  /* !defined (_M_ARM) */


#if defined (__cplusplus)
extern "C" {
#endif  /* defined (__cplusplus) */


///////////////////////////////////////////////////////////////////////////////
//
#if !defined (_ADVSIMD_ALIGN)
#if defined (__midl)
#define _ADVSIMD_ALIGN(x)
#else  /* defined (__midl) */
#define _ADVSIMD_ALIGN(x) __declspec(align(x))
#endif  /* defined (__midl) */
#endif  /* !defined (_ADVSIMD_ALIGN) */

#ifndef DUMMYNEONSTRUCT
#define DUMMYNEONSTRUCT s
#endif  /* DUMMYNEONSTRUCT */

///////////////////////////////////////////////////////////////////////////////
//
// ARM Advanced SIMD 64bit type
//
typedef union __declspec(intrin_type) _ADVSIMD_ALIGN(8) __n64
{
    unsigned __int64    n64_u64[1];
    unsigned __int32    n64_u32[2];
    unsigned __int16    n64_u16[4];
    unsigned __int8     n64_u8[8];
    __int64             n64_i64[1];
    __int32             n64_i32[2];
    __int16             n64_i16[4];
    __int8              n64_i8[8];
    float               n64_f32[2];
} __n64;


///////////////////////////////////////////////////////////////////////////////
//
// ARM Advanced SIMD 128bit type
//
typedef union __declspec(intrin_type) _ADVSIMD_ALIGN(8) __n128
{
     unsigned __int64   n128_u64[2];
     unsigned __int32   n128_u32[4];
     unsigned __int16   n128_u16[8];
     unsigned __int8    n128_u8[16];
     __int64            n128_i64[2];
     __int32            n128_i32[4];
     __int16            n128_i16[8];
     __int8             n128_i8[16];
     float              n128_f32[4];

    struct
    {
        __n64  low64;
        __n64  high64;
    } DUMMYNEONSTRUCT;

} __n128;

typedef struct __n64x2
{
    __n64 val[2];
} __n64x2;

typedef struct __n64x3
{
    __n64 val[3];
} __n64x3;

typedef struct __n64x4
{
    __n64 val[4];
} __n64x4;

typedef struct __n128x2
{
    __n128 val[2];
} __n128x2;

typedef struct __n128x3
{
    __n128 val[3];
} __n128x3;

typedef struct __n128x4
{
    __n128 val[4];
} __n128x4;

///////////////////////////////////////////////////////////////////////////////
//
typedef unsigned __int8  poly8_t;
typedef unsigned __int16 poly16_t;

typedef float float32_t;

#if !defined(_ARM_USE_NEW_NEON_INTRINSICS)
// Once a version is determined, this should default based on _MSC_FULL_VER
#define _ARM_USE_DEPRECATED_NEON_INTRINSICS
#endif

#if defined(_ARM_USE_DEPRECATED_NEON_INTRINSICS)

///////////////////////////////////////////////////////////////////////////////
//
__inline _Post_equal_to_(p) __n64 *__int8ToN64(_Pre_notnull_ _Const_ int8_t *p)       { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__int16ToN64(_Pre_notnull_ _Const_ int16_t *p)     { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__int32ToN64(_Pre_notnull_ _Const_ int32_t *p)     { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__int64ToN64(_Pre_notnull_ _Const_ int64_t *p)     { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__uint8ToN64(_Pre_notnull_ _Const_ uint8_t *p)     { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__uint16ToN64(_Pre_notnull_ _Const_ uint16_t *p)   { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__uint32ToN64(_Pre_notnull_ _Const_ uint32_t *p)   { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__uint64ToN64(_Pre_notnull_ _Const_ uint64_t *p)   { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__poly8ToN64(_Pre_notnull_ _Const_ poly8_t *p)     { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__poly16ToN64(_Pre_notnull_ _Const_ poly16_t *p)   { return (__n64 *)p; }
__inline _Post_equal_to_(p) __n64 *__float32ToN64(_Pre_notnull_ _Const_ float32_t *p) { return (__n64 *)p; }

__inline _Post_equal_to_(p) const __n64 *__int8ToN64_c(_Pre_notnull_ _Const_ const int8_t *p)       { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__int16ToN64_c(_Pre_notnull_ _Const_ const int16_t *p)     { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__int32ToN64_c(_Pre_notnull_ _Const_ const int32_t *p)     { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__int64ToN64_c(_Pre_notnull_ _Const_ const int64_t *p)     { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__uint8ToN64_c(_Pre_notnull_ _Const_ const uint8_t *p)     { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__uint16ToN64_c(_Pre_notnull_ _Const_ const uint16_t *p)   { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__uint32ToN64_c(_Pre_notnull_ _Const_ const uint32_t *p)   { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__uint64ToN64_c(_Pre_notnull_ _Const_ const uint64_t *p)   { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__poly8ToN64_c(_Pre_notnull_ _Const_ const poly8_t *p)     { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__poly16ToN64_c(_Pre_notnull_ _Const_ const poly16_t *p)   { return (const __n64 *)p; }
__inline _Post_equal_to_(p) const __n64 *__float32ToN64_c(_Pre_notnull_ _Const_ const float32_t *p) { return (const __n64 *)p; }

__inline int32_t __int8ToInt32(int8_t i)      { return (int32_t)i; }
__inline int32_t __int16ToInt32(int16_t i)    { return (int32_t)i; }
__inline int32_t __int32ToInt32(int32_t i)    { return (int32_t)i; }
__inline int64_t __int64ToInt64(int64_t i)    { return (int64_t)i; }

__inline int32_t __uint8ToInt32(uint8_t i)    { return (int32_t)i; }
__inline int32_t __uint16ToInt32(uint16_t i)  { return (int32_t)i; }
__inline int32_t __uint32ToInt32(uint32_t i)  { return (int32_t)i; }
__inline int64_t __uint64ToInt64(uint64_t i)  { return (int64_t)i; }

__inline int32_t __poly8ToInt32(poly8_t i)    { return (int32_t)i; }
__inline int32_t __poly16ToInt32(poly16_t i)  { return (int32_t)i; }

///////////////////////////////////////////////////////////////////////////////
//
#define vshll_n_s8(Dm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) <= 8,  "invalid shift amount"), ((shift_amount) == 8)  ? __internal_vshll_n_t2_s8((Dm))  : __internal_vshll_n_t1_s8((Dm),  (shift_amount)) )
#define vshll_n_s16(Dm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) <= 16, "invalid shift amount"), ((shift_amount) == 16) ? __internal_vshll_n_t2_s16((Dm)) : __internal_vshll_n_t1_s16((Dm), (shift_amount)) )
#define vshll_n_s32(Dm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) <= 32, "invalid shift amount"), ((shift_amount) == 32) ? __internal_vshll_n_t2_s32((Dm)) : __internal_vshll_n_t1_s32((Dm), (shift_amount)) )
#define vshll_n_u8(Dm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) <= 8,  "invalid shift amount"), ((shift_amount) == 8)  ? __internal_vshll_n_t2_u8((Dm))  : __internal_vshll_n_t1_u8((Dm),  (shift_amount)) )
#define vshll_n_u16(Dm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) <= 16, "invalid shift amount"), ((shift_amount) == 16) ? __internal_vshll_n_t2_u16((Dm)) : __internal_vshll_n_t1_u16((Dm), (shift_amount)) )
#define vshll_n_u32(Dm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) <= 32, "invalid shift amount"), ((shift_amount) == 32) ? __internal_vshll_n_t2_u32((Dm)) : __internal_vshll_n_t1_u32((Dm), (shift_amount)) )

#endif


///////////////////////////////////////////////////////////////////////////////
//
// { +++ auto-generated code begins (explicit types)

typedef __n64    float32x2_t;
typedef __n64x2  float32x2x2_t;
typedef __n64x3  float32x2x3_t;
typedef __n64x4  float32x2x4_t;
typedef __n64    int8x8_t;
typedef __n64x2  int8x8x2_t;
typedef __n64x3  int8x8x3_t;
typedef __n64x4  int8x8x4_t;
typedef __n64    int16x4_t;
typedef __n64x2  int16x4x2_t;
typedef __n64x3  int16x4x3_t;
typedef __n64x4  int16x4x4_t;
typedef __n64    int32x2_t;
typedef __n64x2  int32x2x2_t;
typedef __n64x3  int32x2x3_t;
typedef __n64x4  int32x2x4_t;
typedef __n64    int64x1_t;
typedef __n64x2  int64x1x2_t;
typedef __n64x3  int64x1x3_t;
typedef __n64x4  int64x1x4_t;
typedef __n64    poly8x8_t;
typedef __n64x2  poly8x8x2_t;
typedef __n64x3  poly8x8x3_t;
typedef __n64x4  poly8x8x4_t;
typedef __n64    poly16x4_t;
typedef __n64x2  poly16x4x2_t;
typedef __n64x3  poly16x4x3_t;
typedef __n64x4  poly16x4x4_t;
typedef __n64    uint8x8_t;
typedef __n64x2  uint8x8x2_t;
typedef __n64x3  uint8x8x3_t;
typedef __n64x4  uint8x8x4_t;
typedef __n64    uint16x4_t;
typedef __n64x2  uint16x4x2_t;
typedef __n64x3  uint16x4x3_t;
typedef __n64x4  uint16x4x4_t;
typedef __n64    uint32x2_t;
typedef __n64x2  uint32x2x2_t;
typedef __n64x3  uint32x2x3_t;
typedef __n64x4  uint32x2x4_t;
typedef __n64    uint64x1_t;
typedef __n64x2  uint64x1x2_t;
typedef __n64x3  uint64x1x3_t;
typedef __n64x4  uint64x1x4_t;
typedef __n128   float32x4_t;
typedef __n128x2 float32x4x2_t;
typedef __n128x3 float32x4x3_t;
typedef __n128x4 float32x4x4_t;
typedef __n128   int8x16_t;
typedef __n128x2 int8x16x2_t;
typedef __n128x3 int8x16x3_t;
typedef __n128x4 int8x16x4_t;
typedef __n128   int16x8_t;
typedef __n128x2 int16x8x2_t;
typedef __n128x3 int16x8x3_t;
typedef __n128x4 int16x8x4_t;
typedef __n128   int32x4_t;
typedef __n128x2 int32x4x2_t;
typedef __n128x3 int32x4x3_t;
typedef __n128x4 int32x4x4_t;
typedef __n128   int64x2_t;
typedef __n128x2 int64x2x2_t;
typedef __n128x3 int64x2x3_t;
typedef __n128x4 int64x2x4_t;
typedef __n128   poly8x16_t;
typedef __n128x2 poly8x16x2_t;
typedef __n128x3 poly8x16x3_t;
typedef __n128x4 poly8x16x4_t;
typedef __n128   poly16x8_t;
typedef __n128x2 poly16x8x2_t;
typedef __n128x3 poly16x8x3_t;
typedef __n128x4 poly16x8x4_t;
typedef __n128   uint8x16_t;
typedef __n128x2 uint8x16x2_t;
typedef __n128x3 uint8x16x3_t;
typedef __n128x4 uint8x16x4_t;
typedef __n128   uint16x8_t;
typedef __n128x2 uint16x8x2_t;
typedef __n128x3 uint16x8x3_t;
typedef __n128x4 uint16x8x4_t;
typedef __n128   uint32x4_t;
typedef __n128x2 uint32x4x2_t;
typedef __n128x3 uint32x4x3_t;
typedef __n128x4 uint32x4x4_t;
typedef __n128   uint64x2_t;
typedef __n128x2 uint64x2x2_t;
typedef __n128x3 uint64x2x3_t;
typedef __n128x4 uint64x2x4_t;

// } +++ auto-generated code ends (explicit types)

#if defined(_ARM_USE_DEPRECATED_NEON_INTRINSICS)

///////////////////////////////////////////////////////////////////////////////
//
// { +++ auto-generated code begins (prototypes)

__n64x2 __neon_DdDm_acc2(unsigned int _Enc, __n64, __n64);
__n64x2 __neon_Dx2Adr(unsigned int _Enc, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n64x2 __neon_Dx2Adr_acc(unsigned int _Enc, __n64x2, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n64x3 __neon_Dx3Adr(unsigned int _Enc, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n64x3 __neon_Dx3Adr_acc(unsigned int _Enc, __n64x3, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n64x4 __neon_Dx4Adr(unsigned int _Enc, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n64x4 __neon_Dx4Adr_acc(unsigned int _Enc, __n64x4, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n64 __neon_DdDm(unsigned int _Enc, __n64);
__n64 __neon_DdDx2Dm(unsigned int _Enc, __n64x2, __n64);
__n64 __neon_DdDx2Dm_acc(unsigned int _Enc, __n64, __n64x2, __n64);
__n64 __neon_DdDx3Dm(unsigned int _Enc, __n64x3, __n64);
__n64 __neon_DdDx3Dm_acc(unsigned int _Enc, __n64, __n64x3, __n64);
__n64 __neon_DdDx4Dm(unsigned int _Enc, __n64x4, __n64);
__n64 __neon_DdDx4Dm_acc(unsigned int _Enc, __n64, __n64x4, __n64);
__n64 __neon_DdDm_acc(unsigned int _Enc, __n64, __n64);
__n64 __neon_DdDnDm(unsigned int _Enc, __n64, __n64);
__n64 __neon_DdDnDm_acc(unsigned int _Enc, __n64, __n64, __n64);
__n64 __neon_DdDnDmx(unsigned int _Enc, __n64, __n64);
__n64 __neon_DdDnDmx_acc(unsigned int _Enc, __n64, __n64, __n64);
__n64 __neon_DdDnFt(unsigned int, __n64, float);
__n64 __neon_DdDnFt_acc(unsigned int, __n64, __n64, float);
__n64 __neon_DdFt(unsigned int _Enc, float);
__n64 __neon_DdFt_acc(unsigned int _Enc, __n64, float);
__n64 __neon_D1Adr(unsigned int _Enc, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n64 __neon_D1Adr_acc(unsigned int _Enc, __n64, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n64 __neon_DdQm(unsigned int _Enc, __n128);
__n64 __neon_DdQm_high(unsigned int _Enc, __n128);
__n64 __neon_DdQm_low(unsigned int _Enc, __n128);
__n64 __neon_DdQnQm(unsigned int _Enc, __n128, __n128);
__n64 __neon_DdRt(unsigned int _Enc, int);
__n64 __neon_DdRtRt2(unsigned int _Enc, __int64);
__n64 __neon_DdRtRt2_acc(unsigned int _Enc, __n64, __int64);
__n64 __neon_DdRt_acc(unsigned int _Enc, __n64, int);
float __neon_FtDn(unsigned int _Enc, __n64);
float __neon_FtQn(unsigned int _Enc, __n128);
__n128x2 __neon_Qx2Adr(unsigned int _Enc, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n128x2 __neon_Qx2Adr_acc(unsigned int _Enc, __n128x2, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n128x2 __neon_QdQm_acc2(unsigned int _Enc, __n128, __n128);
__n128x2 __neon_QdQm_acc3(unsigned int _Enc, __n128, __n128);
__n128x3 __neon_Qx3Adr(unsigned int _Enc, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n128x3 __neon_Qx3Adr_acc(unsigned int _Enc, __n128x3, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n128x4 __neon_Qx4Adr(unsigned int _Enc, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n128x4 __neon_Qx4Adr_acc(unsigned int _Enc, __n128x4, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n128 __neon_QdDm(unsigned int _Enc, __n64);
__n128 __neon_QdDnDm(unsigned int _Enc, __n64, __n64);
__n128 __neon_QdDnDm_acc(unsigned int _Enc, __n128, __n64, __n64);
__n128 __neon_QdDnDm_merge(unsigned int _Enc, __n64, __n64);
__n128 __neon_QdDnDmx(unsigned int _Enc, __n64, __n64);
__n128 __neon_QdDnDmx_acc(unsigned int _Enc, __n128, __n64, __n64);
__n128 __neon_QdFt(unsigned int _Enc, float);
__n128 __neon_QdFt_acc(unsigned int _Enc, __n128, float);
__n128 __neon_Q1Adr(unsigned int _Enc, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n128 __neon_Q1Adr_acc(unsigned int _Enc, __n128, _In_reads_bytes_(_Inexpressible_(_Enc)) const __n64*);
__n128 __neon_QdQm(unsigned int _Enc, __n128);
__n128 __neon_QdQm_acc(unsigned int _Enc, __n128, __n128);
__n128 __neon_QdQnDm(unsigned int _Enc, __n128, __n64);
__n128 __neon_QdQnDmx(unsigned int _Enc, __n128, __n64);
__n128 __neon_QdQnDmx_acc(unsigned int _Enc, __n128, __n128, __n64);
__n128 __neon_QdQnFt(unsigned int, __n128, float);
__n128 __neon_QdQnFt_acc(unsigned int, __n128, __n128, float);
__n128 __neon_QdQnQm(unsigned int _Enc, __n128, __n128);
__n128 __neon_QdQnQm_acc(unsigned int _Enc, __n128, __n128, __n128);
__n128 __neon_QdRt(unsigned int _Enc, int);
__n128 __neon_QdRtRt2_acc(unsigned int _Enc, __n128, __int64);
__n128 __neon_QdRtRt2_dup(unsigned int _Enc, __int64);
__n128 __neon_QdRt_acc(unsigned int _Enc, __n128, int);
__int64 __neon_RtRt2Dm(unsigned int _Enc, __n64);
__int64 __neon_RtRt2Qm(unsigned int _Enc, __n128);
int __neon_RtDn(unsigned int _Enc, __n64);
int __neon_RtQn(unsigned int _Enc, __n128);
void __neon_AdrD1(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n64);
void __neon_AdrDx2(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n64x2);
void __neon_AdrDx2x(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n64x2);
void __neon_AdrDx3(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n64x3);
void __neon_AdrDx3x(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n64x3);
void __neon_AdrDx4(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n64x4);
void __neon_AdrDx4x(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n64x4);
void __neon_AdrQ1(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n128);
void __neon_AdrQx2(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n128x2);
void __neon_AdrQx2x(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n128x2);
void __neon_AdrQx3(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n128x3);
void __neon_AdrQx3x(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n128x3);
void __neon_AdrQx4(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n128x4);
void __neon_AdrQx4x(unsigned int _Enc, _Out_writes_bytes_(_Inexpressible_(_Enc)) __n64*, __n128x4);

// } +++ auto-generated code ends (prototypes)

#endif

#if defined (__cplusplus)
}
#endif  /* defined (__cplusplus) */

#if defined(_ARM_USE_DEPRECATED_NEON_INTRINSICS)

///////////////////////////////////////////////////////////////////////////////
//
// VLDx/VSTx alignment specifications
//


#define _NEON_ALIGN16(a)         \
    (                            \
    ((a) == 8) ? 0 :             \
    ((a) == 16) ? 1 :            \
    -1)

#define _NEON_ALIGN32(a)         \
    (                            \
    ((a) == 8) ? 0 :             \
    ((a) == 32) ? 1 :            \
    -1)

#define _NEON_ALIGN64(a)         \
    (                            \
    ((a) == 8) ? 0 :             \
    ((a) == 64) ? 1 :            \
    -1)

#define _NEON_ALIGN64_128(a)     \
    (                            \
    ((a) == 8) ? 0 :             \
    ((a) == 64) ? 1 :            \
    ((a) == 128) ? 2 :           \
    -1)


#define _NEON_ALIGN64_128_256(a) \
    (                            \
    ((a) == 8) ? 0 :             \
    ((a) == 64) ? 1 :            \
    ((a) == 128) ? 2 :           \
    ((a) == 256) ? 3 :           \
    -1)


///////////////////////////////////////////////////////////////////////////////
//
// { +++ auto-generated code begins (encoding macros)

#define _NENC_0(x)                               ((x) & 0x1)
#define _NENC_11_8(x)                            (((x) << 8) & 0xf00)
#define _NENC_12(x)                              (((x) << 12) & 0x1000)
#define _NENC_16(x)                              (((x) << 16) & 0x10000)
#define _NENC_18_16(x)                           (((x) << 16) & 0x70000)
#define _NENC_19(x)                              (((x) << 19) & 0x80000)
#define _NENC_19_16(x)                           (((x) << 16) & 0xf0000)
#define _NENC_19_17(x)                           (((x) << 17) & 0xe0000)
#define _NENC_19_18(x)                           (((x) << 18) & 0xc0000)
#define _NENC_20_16(x)                           (((x) << 16) & 0x1f0000)
#define _NENC_21(x)                              (((x) << 21) & 0x200000)
#define _NENC_21_16(x)                           (((x) << 16) & 0x3f0000)
#define _NENC_21x6(x)                            (((x) << 6) & 0x40 | ((x) << 20) & 0x200000)
#define _NENC_21x6_5(x)                          (((x) << 5) & 0x60 | ((x) << 19) & 0x200000)
#define _NENC_4(x)                               (((x) << 4) & 0x10)
#define _NENC_5(x)                               (((x) << 5) & 0x20)
#define _NENC_5_4(x)                             (((x) << 4) & 0x30)
#define _NENC_5x3(x)                             (((x) << 3) & 0x8 | ((x) << 4) & 0x20)
#define _NENC_7(x)                               (((x) << 7) & 0x80)
#define _NENC_7_5(x)                             (((x) << 5) & 0xe0)
#define _NENC_7_6(x)                             (((x) << 6) & 0xc0)

// } +++ auto-generated code ends (encoding macros)


///////////////////////////////////////////////////////////////////////////////
//
// { +++ auto-generated code begins (Neon macros)

// AES
#define aesd_p8(Qm)                              ( __neon_QdQm( 0xf3b00340, (Qm)) )
#define aesd_s8(Qm)                              ( __neon_QdQm( 0xf3b00340, (Qm)) )
#define aesd_u8(Qm)                              ( __neon_QdQm( 0xf3b00340, (Qm)) )
#define aese_p8(Qm)                              ( __neon_QdQm( 0xf3b00300, (Qm)) )
#define aese_s8(Qm)                              ( __neon_QdQm( 0xf3b00300, (Qm)) )
#define aese_u8(Qm)                              ( __neon_QdQm( 0xf3b00300, (Qm)) )
#define aesimc_p8(Qm)                            ( __neon_QdQm( 0xf3b003c0, (Qm)) )
#define aesimc_s8(Qm)                            ( __neon_QdQm( 0xf3b003c0, (Qm)) )
#define aesimc_u8(Qm)                            ( __neon_QdQm( 0xf3b003c0, (Qm)) )
#define aesmc_p8(Qm)                             ( __neon_QdQm( 0xf3b00380, (Qm)) )
#define aesmc_s8(Qm)                             ( __neon_QdQm( 0xf3b00380, (Qm)) )
#define aesmc_u8(Qm)                             ( __neon_QdQm( 0xf3b00380, (Qm)) )

// SHA (2-operand)
#define sha1h_f32(Qm)                            ( __neon_QdQm( 0xf3b902c0, (Qm)) )
#define sha1h_s32(Qm)                            ( __neon_QdQm( 0xf3b902c0, (Qm)) )
#define sha1h_u32(Qm)                            ( __neon_QdQm( 0xf3b902c0, (Qm)) )
#define sha1su1_f32(Qm)                          ( __neon_QdQm( 0xf3ba0380, (Qm)) )
#define sha1su1_s32(Qm)                          ( __neon_QdQm( 0xf3ba0380, (Qm)) )
#define sha1su1_u32(Qm)                          ( __neon_QdQm( 0xf3ba0380, (Qm)) )
#define sha256su0_f32(Qm)                        ( __neon_QdQm( 0xf3ba03c0, (Qm)) )
#define sha256su0_s32(Qm)                        ( __neon_QdQm( 0xf3ba03c0, (Qm)) )
#define sha256su0_u32(Qm)                        ( __neon_QdQm( 0xf3ba03c0, (Qm)) )

// SHA (3-operand)
#define sha1c_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000c40, (Qn), (Qm)) )
#define sha1c_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000c40, (Qn), (Qm)) )
#define sha1c_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000c40, (Qn), (Qm)) )
#define sha1m_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200c40, (Qn), (Qm)) )
#define sha1m_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200c40, (Qn), (Qm)) )
#define sha1m_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200c40, (Qn), (Qm)) )
#define sha1p_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100c40, (Qn), (Qm)) )
#define sha1p_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100c40, (Qn), (Qm)) )
#define sha1p_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100c40, (Qn), (Qm)) )
#define sha1su0_f32(Qn, Qm)                      ( __neon_QdQnQm( 0xf2300c40, (Qn), (Qm)) )
#define sha1su0_s32(Qn, Qm)                      ( __neon_QdQnQm( 0xf2300c40, (Qn), (Qm)) )
#define sha1su0_u32(Qn, Qm)                      ( __neon_QdQnQm( 0xf2300c40, (Qn), (Qm)) )
#define sha256h_f32(Qn, Qm)                      ( __neon_QdQnQm( 0xf3000c40, (Qn), (Qm)) )
#define sha256h_s32(Qn, Qm)                      ( __neon_QdQnQm( 0xf3000c40, (Qn), (Qm)) )
#define sha256h_u32(Qn, Qm)                      ( __neon_QdQnQm( 0xf3000c40, (Qn), (Qm)) )
#define sha256h2_f32(Qn, Qm)                     ( __neon_QdQnQm( 0xf3100c40, (Qn), (Qm)) )
#define sha256h2_s32(Qn, Qm)                     ( __neon_QdQnQm( 0xf3100c40, (Qn), (Qm)) )
#define sha256h2_u32(Qn, Qm)                     ( __neon_QdQnQm( 0xf3100c40, (Qn), (Qm)) )
#define sha256su1_f32(Qn, Qm)                    ( __neon_QdQnQm( 0xf3200c40, (Qn), (Qm)) )
#define sha256su1_s32(Qn, Qm)                    ( __neon_QdQnQm( 0xf3200c40, (Qn), (Qm)) )
#define sha256su1_u32(Qn, Qm)                    ( __neon_QdQnQm( 0xf3200c40, (Qn), (Qm)) )

// VABA, VABAL
#define vaba_s16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf2100710, (Dd), (Dn), (Dm)) )
#define vaba_s32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf2200710, (Dd), (Dn), (Dm)) )
#define vaba_s8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf2000710, (Dd), (Dn), (Dm)) )
#define vaba_u16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100710, (Dd), (Dn), (Dm)) )
#define vaba_u32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200710, (Dd), (Dn), (Dm)) )
#define vaba_u8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3000710, (Dd), (Dn), (Dm)) )
#define vabal_s16(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf2900500, (Qd), (Dn), (Dm)) )
#define vabal_s32(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf2a00500, (Qd), (Dn), (Dm)) )
#define vabal_s8(Qd, Dn, Dm)                     ( __neon_QdDnDm_acc( 0xf2800500, (Qd), (Dn), (Dm)) )
#define vabal_u16(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf3900500, (Qd), (Dn), (Dm)) )
#define vabal_u32(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf3a00500, (Qd), (Dn), (Dm)) )
#define vabal_u8(Qd, Dn, Dm)                     ( __neon_QdDnDm_acc( 0xf3800500, (Qd), (Dn), (Dm)) )
#define vabaq_s16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf2100750, (Qd), (Qn), (Qm)) )
#define vabaq_s32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf2200750, (Qd), (Qn), (Qm)) )
#define vabaq_s8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf2000750, (Qd), (Qn), (Qm)) )
#define vabaq_u16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100750, (Qd), (Qn), (Qm)) )
#define vabaq_u32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200750, (Qd), (Qn), (Qm)) )
#define vabaq_u8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3000750, (Qd), (Qn), (Qm)) )

// VABD (floating point)
#define vabd_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200d00, (Dn), (Dm)) )
#define vabdq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200d40, (Qn), (Qm)) )

// VABD[L] (integer)
#define vabd_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100700, (Dn), (Dm)) )
#define vabd_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200700, (Dn), (Dm)) )
#define vabd_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000700, (Dn), (Dm)) )
#define vabd_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100700, (Dn), (Dm)) )
#define vabd_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200700, (Dn), (Dm)) )
#define vabd_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000700, (Dn), (Dm)) )
#define vabdl_s16(Dn, Dm)                        ( __neon_QdDnDm( 0xf2900700, (Dn), (Dm)) )
#define vabdl_s32(Dn, Dm)                        ( __neon_QdDnDm( 0xf2a00700, (Dn), (Dm)) )
#define vabdl_s8(Dn, Dm)                         ( __neon_QdDnDm( 0xf2800700, (Dn), (Dm)) )
#define vabdl_u16(Dn, Dm)                        ( __neon_QdDnDm( 0xf3900700, (Dn), (Dm)) )
#define vabdl_u32(Dn, Dm)                        ( __neon_QdDnDm( 0xf3a00700, (Dn), (Dm)) )
#define vabdl_u8(Dn, Dm)                         ( __neon_QdDnDm( 0xf3800700, (Dn), (Dm)) )
#define vabdq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100740, (Qn), (Qm)) )
#define vabdq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200740, (Qn), (Qm)) )
#define vabdq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000740, (Qn), (Qm)) )
#define vabdq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100740, (Qn), (Qm)) )
#define vabdq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200740, (Qn), (Qm)) )
#define vabdq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000740, (Qn), (Qm)) )

// VABS, VNEG
#define vabs_f32(Dm)                             ( __neon_DdDm( 0xf3b90700, (Dm)) )
#define vabs_s16(Dm)                             ( __neon_DdDm( 0xf3b50300, (Dm)) )
#define vabs_s32(Dm)                             ( __neon_DdDm( 0xf3b90300, (Dm)) )
#define vabs_s8(Dm)                              ( __neon_DdDm( 0xf3b10300, (Dm)) )
#define vneg_f32(Dm)                             ( __neon_DdDm( 0xf3b90780, (Dm)) )
#define vneg_s16(Dm)                             ( __neon_DdDm( 0xf3b50380, (Dm)) )
#define vneg_s32(Dm)                             ( __neon_DdDm( 0xf3b90380, (Dm)) )
#define vneg_s8(Dm)                              ( __neon_DdDm( 0xf3b10380, (Dm)) )
#define vabsq_f32(Qm)                            ( __neon_QdQm( 0xf3b90740, (Qm)) )
#define vabsq_s16(Qm)                            ( __neon_QdQm( 0xf3b50340, (Qm)) )
#define vabsq_s32(Qm)                            ( __neon_QdQm( 0xf3b90340, (Qm)) )
#define vabsq_s8(Qm)                             ( __neon_QdQm( 0xf3b10340, (Qm)) )
#define vnegq_f32(Qm)                            ( __neon_QdQm( 0xf3b907c0, (Qm)) )
#define vnegq_s16(Qm)                            ( __neon_QdQm( 0xf3b503c0, (Qm)) )
#define vnegq_s32(Qm)                            ( __neon_QdQm( 0xf3b903c0, (Qm)) )
#define vnegq_s8(Qm)                             ( __neon_QdQm( 0xf3b103c0, (Qm)) )

// VACGE, VACGT, VACLE, VACLT
#define vacge_f32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3000e10, (Dn), (Dm)) )
#define vacgt_f32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200e10, (Dn), (Dm)) )
#define vacle_f32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3000e10, (Dm), (Dn)) )
#define vaclt_f32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200e10, (Dm), (Dn)) )
#define vacgeq_f32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3000e50, (Qn), (Qm)) )
#define vacgtq_f32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3200e50, (Qn), (Qm)) )
#define vacleq_f32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3000e50, (Qm), (Qn)) )
#define vacltq_f32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3200e50, (Qm), (Qn)) )

// VADD
#define vadd_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000d00, (Dn), (Dm)) )
#define vadd_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100800, (Dn), (Dm)) )
#define vadd_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200800, (Dn), (Dm)) )
#define vadd_s64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300800, (Dn), (Dm)) )
#define vadd_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000800, (Dn), (Dm)) )
#define vadd_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100800, (Dn), (Dm)) )
#define vadd_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200800, (Dn), (Dm)) )
#define vadd_u64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300800, (Dn), (Dm)) )
#define vadd_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000800, (Dn), (Dm)) )
#define vaddq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000d40, (Qn), (Qm)) )
#define vaddq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100840, (Qn), (Qm)) )
#define vaddq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200840, (Qn), (Qm)) )
#define vaddq_s64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300840, (Qn), (Qm)) )
#define vaddq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000840, (Qn), (Qm)) )
#define vaddq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100840, (Qn), (Qm)) )
#define vaddq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200840, (Qn), (Qm)) )
#define vaddq_u64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300840, (Qn), (Qm)) )
#define vaddq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000840, (Qn), (Qm)) )

// VADDHN, VRADDHN
#define vaddhn_s16(Qn, Qm)                       ( __neon_DdQnQm( 0xf2800400, (Qn), (Qm)) )
#define vaddhn_s32(Qn, Qm)                       ( __neon_DdQnQm( 0xf2900400, (Qn), (Qm)) )
#define vaddhn_s64(Qn, Qm)                       ( __neon_DdQnQm( 0xf2a00400, (Qn), (Qm)) )
#define vaddhn_u16(Qn, Qm)                       ( __neon_DdQnQm( 0xf2800400, (Qn), (Qm)) )
#define vaddhn_u32(Qn, Qm)                       ( __neon_DdQnQm( 0xf2900400, (Qn), (Qm)) )
#define vaddhn_u64(Qn, Qm)                       ( __neon_DdQnQm( 0xf2a00400, (Qn), (Qm)) )
#define vraddhn_s16(Qn, Qm)                      ( __neon_DdQnQm( 0xf3800400, (Qn), (Qm)) )
#define vraddhn_s32(Qn, Qm)                      ( __neon_DdQnQm( 0xf3900400, (Qn), (Qm)) )
#define vraddhn_s64(Qn, Qm)                      ( __neon_DdQnQm( 0xf3a00400, (Qn), (Qm)) )
#define vraddhn_u16(Qn, Qm)                      ( __neon_DdQnQm( 0xf3800400, (Qn), (Qm)) )
#define vraddhn_u32(Qn, Qm)                      ( __neon_DdQnQm( 0xf3900400, (Qn), (Qm)) )
#define vraddhn_u64(Qn, Qm)                      ( __neon_DdQnQm( 0xf3a00400, (Qn), (Qm)) )

// VADDL, VADDW
#define vaddl_s16(Dn, Dm)                        ( __neon_QdDnDm( 0xf2900000, (Dn), (Dm)) )
#define vaddl_s32(Dn, Dm)                        ( __neon_QdDnDm( 0xf2a00000, (Dn), (Dm)) )
#define vaddl_s8(Dn, Dm)                         ( __neon_QdDnDm( 0xf2800000, (Dn), (Dm)) )
#define vaddl_u16(Dn, Dm)                        ( __neon_QdDnDm( 0xf3900000, (Dn), (Dm)) )
#define vaddl_u32(Dn, Dm)                        ( __neon_QdDnDm( 0xf3a00000, (Dn), (Dm)) )
#define vaddl_u8(Dn, Dm)                         ( __neon_QdDnDm( 0xf3800000, (Dn), (Dm)) )
#define vaddw_s16(Qn, Dm)                        ( __neon_QdQnDm( 0xf2900100, (Qn), (Dm)) )
#define vaddw_s32(Qn, Dm)                        ( __neon_QdQnDm( 0xf2a00100, (Qn), (Dm)) )
#define vaddw_s8(Qn, Dm)                         ( __neon_QdQnDm( 0xf2800100, (Qn), (Dm)) )
#define vaddw_u16(Qn, Dm)                        ( __neon_QdQnDm( 0xf3900100, (Qn), (Dm)) )
#define vaddw_u32(Qn, Dm)                        ( __neon_QdQnDm( 0xf3a00100, (Qn), (Dm)) )
#define vaddw_u8(Qn, Dm)                         ( __neon_QdQnDm( 0xf3800100, (Qn), (Dm)) )

// VAND, VORR
#define vand_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000110, (Dn), (Dm)) )
#define vand_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000110, (Dn), (Dm)) )
#define vand_s64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000110, (Dn), (Dm)) )
#define vand_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000110, (Dn), (Dm)) )
#define vand_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000110, (Dn), (Dm)) )
#define vand_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000110, (Dn), (Dm)) )
#define vand_u64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000110, (Dn), (Dm)) )
#define vand_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000110, (Dn), (Dm)) )
#define vorr_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200110, (Dn), (Dm)) )
#define vorr_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200110, (Dn), (Dm)) )
#define vorr_s64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200110, (Dn), (Dm)) )
#define vorr_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2200110, (Dn), (Dm)) )
#define vorr_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200110, (Dn), (Dm)) )
#define vorr_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200110, (Dn), (Dm)) )
#define vorr_u64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200110, (Dn), (Dm)) )
#define vorr_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2200110, (Dn), (Dm)) )
#define vandq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000150, (Qn), (Qm)) )
#define vandq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000150, (Qn), (Qm)) )
#define vandq_s64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000150, (Qn), (Qm)) )
#define vandq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000150, (Qn), (Qm)) )
#define vandq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000150, (Qn), (Qm)) )
#define vandq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000150, (Qn), (Qm)) )
#define vandq_u64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000150, (Qn), (Qm)) )
#define vandq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000150, (Qn), (Qm)) )
#define vorrq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200150, (Qn), (Qm)) )
#define vorrq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200150, (Qn), (Qm)) )
#define vorrq_s64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200150, (Qn), (Qm)) )
#define vorrq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2200150, (Qn), (Qm)) )
#define vorrq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200150, (Qn), (Qm)) )
#define vorrq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200150, (Qn), (Qm)) )
#define vorrq_u64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200150, (Qn), (Qm)) )
#define vorrq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2200150, (Qn), (Qm)) )

// VBIF, VBIT, VBSL
#define vbif_f32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_p16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_p8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_s16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_s32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_s64(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_s8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_u16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_u32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_u64(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbif_u8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3300110, (Dd), (Dn), (Dm)) )
#define vbit_f32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_p16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_p8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_s16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_s32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_s64(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_s8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_u16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_u32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_u64(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbit_u8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3200110, (Dd), (Dn), (Dm)) )
#define vbsl_f32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_p16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_p8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_s16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_s32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_s64(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_s8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_u16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_u32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_u64(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbsl_u8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3100110, (Dd), (Dn), (Dm)) )
#define vbifq_f32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_p16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_p8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_s16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_s32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_s64(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_s8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_u16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_u32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_u64(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbifq_u8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3300150, (Qd), (Qn), (Qm)) )
#define vbitq_f32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_p16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_p8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_s16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_s32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_s64(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_s8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_u16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_u32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_u64(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbitq_u8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3200150, (Qd), (Qn), (Qm)) )
#define vbslq_f32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_p16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_p8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_s16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_s32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_s64(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_s8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_u16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_u32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_u64(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )
#define vbslq_u8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3100150, (Qd), (Qn), (Qm)) )

// VCEQ (immediate #0)
#define vceq_z_f32_ex(Dm)                        ( __neon_DdDm( 0xf3b90500, (Dm)) )
#define vceq_z_s16_ex(Dm)                        ( __neon_DdDm( 0xf3b50100, (Dm)) )
#define vceq_z_s32_ex(Dm)                        ( __neon_DdDm( 0xf3b90100, (Dm)) )
#define vceq_z_s8_ex(Dm)                         ( __neon_DdDm( 0xf3b10100, (Dm)) )
#define vceq_z_u16_ex(Dm)                        ( __neon_DdDm( 0xf3b50100, (Dm)) )
#define vceq_z_u32_ex(Dm)                        ( __neon_DdDm( 0xf3b90100, (Dm)) )
#define vceq_z_u8_ex(Dm)                         ( __neon_DdDm( 0xf3b10100, (Dm)) )
#define vceqq_z_f32_ex(Qm)                       ( __neon_QdQm( 0xf3b90540, (Qm)) )
#define vceqq_z_s16_ex(Qm)                       ( __neon_QdQm( 0xf3b50140, (Qm)) )
#define vceqq_z_s32_ex(Qm)                       ( __neon_QdQm( 0xf3b90140, (Qm)) )
#define vceqq_z_s8_ex(Qm)                        ( __neon_QdQm( 0xf3b10140, (Qm)) )
#define vceqq_z_u16_ex(Qm)                       ( __neon_QdQm( 0xf3b50140, (Qm)) )
#define vceqq_z_u32_ex(Qm)                       ( __neon_QdQm( 0xf3b90140, (Qm)) )
#define vceqq_z_u8_ex(Qm)                        ( __neon_QdQm( 0xf3b10140, (Qm)) )

// VCEQ (register)
#define vceq_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000e00, (Dn), (Dm)) )
#define vceq_p8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000810, (Dn), (Dm)) )
#define vceq_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100810, (Dn), (Dm)) )
#define vceq_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200810, (Dn), (Dm)) )
#define vceq_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000810, (Dn), (Dm)) )
#define vceq_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100810, (Dn), (Dm)) )
#define vceq_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200810, (Dn), (Dm)) )
#define vceq_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000810, (Dn), (Dm)) )
#define vceqq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000e40, (Qn), (Qm)) )
#define vceqq_p8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000850, (Qn), (Qm)) )
#define vceqq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100850, (Qn), (Qm)) )
#define vceqq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200850, (Qn), (Qm)) )
#define vceqq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000850, (Qn), (Qm)) )
#define vceqq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100850, (Qn), (Qm)) )
#define vceqq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200850, (Qn), (Qm)) )
#define vceqq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000850, (Qn), (Qm)) )

// VCGE (immediate #0)
#define vcge_z_f32_ex(Dm)                        ( __neon_DdDm( 0xf3b90480, (Dm)) )
#define vcge_z_s16_ex(Dm)                        ( __neon_DdDm( 0xf3b50080, (Dm)) )
#define vcge_z_s32_ex(Dm)                        ( __neon_DdDm( 0xf3b90080, (Dm)) )
#define vcge_z_s8_ex(Dm)                         ( __neon_DdDm( 0xf3b10080, (Dm)) )
#define vcgeq_z_f32_ex(Qm)                       ( __neon_QdQm( 0xf3b904c0, (Qm)) )
#define vcgeq_z_s16_ex(Qm)                       ( __neon_QdQm( 0xf3b500c0, (Qm)) )
#define vcgeq_z_s32_ex(Qm)                       ( __neon_QdQm( 0xf3b900c0, (Qm)) )
#define vcgeq_z_s8_ex(Qm)                        ( __neon_QdQm( 0xf3b100c0, (Qm)) )

// VCGE, VCLE (register)
#define vcge_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000e00, (Dn), (Dm)) )
#define vcge_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100310, (Dn), (Dm)) )
#define vcge_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200310, (Dn), (Dm)) )
#define vcge_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000310, (Dn), (Dm)) )
#define vcge_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100310, (Dn), (Dm)) )
#define vcge_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200310, (Dn), (Dm)) )
#define vcge_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000310, (Dn), (Dm)) )
#define vcle_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000e00, (Dm), (Dn)) )
#define vcle_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100310, (Dm), (Dn)) )
#define vcle_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200310, (Dm), (Dn)) )
#define vcle_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000310, (Dm), (Dn)) )
#define vcle_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100310, (Dm), (Dn)) )
#define vcle_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200310, (Dm), (Dn)) )
#define vcle_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000310, (Dm), (Dn)) )
#define vcgeq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000e40, (Qn), (Qm)) )
#define vcgeq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100350, (Qn), (Qm)) )
#define vcgeq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200350, (Qn), (Qm)) )
#define vcgeq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000350, (Qn), (Qm)) )
#define vcgeq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100350, (Qn), (Qm)) )
#define vcgeq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200350, (Qn), (Qm)) )
#define vcgeq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000350, (Qn), (Qm)) )
#define vcleq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000e40, (Qm), (Qn)) )
#define vcleq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100350, (Qm), (Qn)) )
#define vcleq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200350, (Qm), (Qn)) )
#define vcleq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000350, (Qm), (Qn)) )
#define vcleq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100350, (Qm), (Qn)) )
#define vcleq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200350, (Qm), (Qn)) )
#define vcleq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000350, (Qm), (Qn)) )

// VCGT (immediate #0)
#define vcgt_z_f32_ex(Dm)                        ( __neon_DdDm( 0xf3b90400, (Dm)) )
#define vcgt_z_s16_ex(Dm)                        ( __neon_DdDm( 0xf3b50000, (Dm)) )
#define vcgt_z_s32_ex(Dm)                        ( __neon_DdDm( 0xf3b90000, (Dm)) )
#define vcgt_z_s8_ex(Dm)                         ( __neon_DdDm( 0xf3b10000, (Dm)) )
#define vcgtq_z_f32_ex(Qm)                       ( __neon_QdQm( 0xf3b90440, (Qm)) )
#define vcgtq_z_s16_ex(Qm)                       ( __neon_QdQm( 0xf3b50040, (Qm)) )
#define vcgtq_z_s32_ex(Qm)                       ( __neon_QdQm( 0xf3b90040, (Qm)) )
#define vcgtq_z_s8_ex(Qm)                        ( __neon_QdQm( 0xf3b10040, (Qm)) )

// VCGT, VCLT (register)
#define vcgt_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200e00, (Dn), (Dm)) )
#define vcgt_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100300, (Dn), (Dm)) )
#define vcgt_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200300, (Dn), (Dm)) )
#define vcgt_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000300, (Dn), (Dm)) )
#define vcgt_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100300, (Dn), (Dm)) )
#define vcgt_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200300, (Dn), (Dm)) )
#define vcgt_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000300, (Dn), (Dm)) )
#define vclt_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200e00, (Dm), (Dn)) )
#define vclt_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100300, (Dm), (Dn)) )
#define vclt_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200300, (Dm), (Dn)) )
#define vclt_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000300, (Dm), (Dn)) )
#define vclt_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100300, (Dm), (Dn)) )
#define vclt_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200300, (Dm), (Dn)) )
#define vclt_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000300, (Dm), (Dn)) )
#define vcgtq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200e40, (Qn), (Qm)) )
#define vcgtq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100340, (Qn), (Qm)) )
#define vcgtq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200340, (Qn), (Qm)) )
#define vcgtq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000340, (Qn), (Qm)) )
#define vcgtq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100340, (Qn), (Qm)) )
#define vcgtq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200340, (Qn), (Qm)) )
#define vcgtq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000340, (Qn), (Qm)) )
#define vcltq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200e40, (Qm), (Qn)) )
#define vcltq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100340, (Qm), (Qn)) )
#define vcltq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200340, (Qm), (Qn)) )
#define vcltq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000340, (Qm), (Qn)) )
#define vcltq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100340, (Qm), (Qn)) )
#define vcltq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200340, (Qm), (Qn)) )
#define vcltq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000340, (Qm), (Qn)) )

// VCLE (immediate #0)
#define vcle_z_f32_ex(Dm)                        ( __neon_DdDm( 0xf3b90580, (Dm)) )
#define vcle_z_s16_ex(Dm)                        ( __neon_DdDm( 0xf3b50180, (Dm)) )
#define vcle_z_s32_ex(Dm)                        ( __neon_DdDm( 0xf3b90180, (Dm)) )
#define vcle_z_s8_ex(Dm)                         ( __neon_DdDm( 0xf3b10180, (Dm)) )
#define vcleq_z_f32_ex(Qm)                       ( __neon_QdQm( 0xf3b905c0, (Qm)) )
#define vcleq_z_s16_ex(Qm)                       ( __neon_QdQm( 0xf3b501c0, (Qm)) )
#define vcleq_z_s32_ex(Qm)                       ( __neon_QdQm( 0xf3b901c0, (Qm)) )
#define vcleq_z_s8_ex(Qm)                        ( __neon_QdQm( 0xf3b101c0, (Qm)) )

// VCLS, VCLZ
#define vcls_s16(Dm)                             ( __neon_DdDm( 0xf3b40400, (Dm)) )
#define vcls_s32(Dm)                             ( __neon_DdDm( 0xf3b80400, (Dm)) )
#define vcls_s8(Dm)                              ( __neon_DdDm( 0xf3b00400, (Dm)) )
#define vclz_s16(Dm)                             ( __neon_DdDm( 0xf3b40480, (Dm)) )
#define vclz_s32(Dm)                             ( __neon_DdDm( 0xf3b80480, (Dm)) )
#define vclz_s8(Dm)                              ( __neon_DdDm( 0xf3b00480, (Dm)) )
#define vclz_u16(Dm)                             ( __neon_DdDm( 0xf3b40480, (Dm)) )
#define vclz_u32(Dm)                             ( __neon_DdDm( 0xf3b80480, (Dm)) )
#define vclz_u8(Dm)                              ( __neon_DdDm( 0xf3b00480, (Dm)) )
#define vclsq_s16(Qm)                            ( __neon_QdQm( 0xf3b40440, (Qm)) )
#define vclsq_s32(Qm)                            ( __neon_QdQm( 0xf3b80440, (Qm)) )
#define vclsq_s8(Qm)                             ( __neon_QdQm( 0xf3b00440, (Qm)) )
#define vclzq_s16(Qm)                            ( __neon_QdQm( 0xf3b404c0, (Qm)) )
#define vclzq_s32(Qm)                            ( __neon_QdQm( 0xf3b804c0, (Qm)) )
#define vclzq_s8(Qm)                             ( __neon_QdQm( 0xf3b004c0, (Qm)) )
#define vclzq_u16(Qm)                            ( __neon_QdQm( 0xf3b404c0, (Qm)) )
#define vclzq_u32(Qm)                            ( __neon_QdQm( 0xf3b804c0, (Qm)) )
#define vclzq_u8(Qm)                             ( __neon_QdQm( 0xf3b004c0, (Qm)) )

// VCLT (immediate #0)
#define vclt_z_f32_ex(Dm)                        ( __neon_DdDm( 0xf3b90600, (Dm)) )
#define vclt_z_s16_ex(Dm)                        ( __neon_DdDm( 0xf3b50200, (Dm)) )
#define vclt_z_s32_ex(Dm)                        ( __neon_DdDm( 0xf3b90200, (Dm)) )
#define vclt_z_s8_ex(Dm)                         ( __neon_DdDm( 0xf3b10200, (Dm)) )
#define vcltq_z_f32_ex(Qm)                       ( __neon_QdQm( 0xf3b90640, (Qm)) )
#define vcltq_z_s16_ex(Qm)                       ( __neon_QdQm( 0xf3b50240, (Qm)) )
#define vcltq_z_s32_ex(Qm)                       ( __neon_QdQm( 0xf3b90240, (Qm)) )
#define vcltq_z_s8_ex(Qm)                        ( __neon_QdQm( 0xf3b10240, (Qm)) )

// VCNT
#define vcnt_p8(Dm)                              ( __neon_DdDm( 0xf3b00500, (Dm)) )
#define vcnt_s8(Dm)                              ( __neon_DdDm( 0xf3b00500, (Dm)) )
#define vcnt_u8(Dm)                              ( __neon_DdDm( 0xf3b00500, (Dm)) )
#define vcntq_p8(Qm)                             ( __neon_QdQm( 0xf3b00540, (Qm)) )
#define vcntq_s8(Qm)                             ( __neon_QdQm( 0xf3b00540, (Qm)) )
#define vcntq_u8(Qm)                             ( __neon_QdQm( 0xf3b00540, (Qm)) )

// VCOMBINE (combine 2x64bit into a 128bit register)
#define vcombine_f32(Dn, Dm)                     ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_p16(Dn, Dm)                     ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_p8(Dn, Dm)                      ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_s16(Dn, Dm)                     ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_s32(Dn, Dm)                     ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_s64(Dn, Dm)                     ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_s8(Dn, Dm)                      ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_u16(Dn, Dm)                     ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_u32(Dn, Dm)                     ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_u64(Dn, Dm)                     ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )
#define vcombine_u8(Dn, Dm)                      ( __neon_QdDnDm_merge( 0x00000000, (Dn), (Dm)) )

// VCREATE (ARM core register pair to Neon 64bit register)
#define vcreate_f32(R64t)                        ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_p16(R64t)                        ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_p8(R64t)                         ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_s16(R64t)                        ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_s32(R64t)                        ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_s64(R64t)                        ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_s8(R64t)                         ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_u16(R64t)                        ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_u32(R64t)                        ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_u64(R64t)                        ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vcreate_u8(R64t)                         ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )

// VCVT (between floating-point and fixed-point)
#define vcvt_n_f32_s32(Dm, fbits)                ( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_DdDm( 0xf2800e10 | _NENC_21_16(64 - (fbits)), (Dm)) )
#define vcvt_n_f32_u32(Dm, fbits)                ( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_DdDm( 0xf3800e10 | _NENC_21_16(64 - (fbits)), (Dm)) )
#define vcvt_n_s32_f32(Dm, fbits)                ( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_DdDm( 0xf2800f10 | _NENC_21_16(64 - (fbits)), (Dm)) )
#define vcvt_n_u32_f32(Dm, fbits)                ( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_DdDm( 0xf3800f10 | _NENC_21_16(64 - (fbits)), (Dm)) )
#define vcvtq_n_f32_s32(Qm, fbits)               ( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_QdQm( 0xf2800e50 | _NENC_21_16(64 - (fbits)), (Qm)) )
#define vcvtq_n_f32_u32(Qm, fbits)               ( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_QdQm( 0xf3800e50 | _NENC_21_16(64 - (fbits)), (Qm)) )
#define vcvtq_n_s32_f32(Qm, fbits)               ( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_QdQm( 0xf2800f50 | _NENC_21_16(64 - (fbits)), (Qm)) )
#define vcvtq_n_u32_f32(Qm, fbits)               ( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_QdQm( 0xf3800f50 | _NENC_21_16(64 - (fbits)), (Qm)) )

// VCVT (between floating-point and integer with directed rounding)
#define vcvta_s32_f32(Dm)                        ( __neon_DdDm( 0xf3bb0000, (Dm)) )
#define vcvta_u32_f32(Dm)                        ( __neon_DdDm( 0xf3bb0080, (Dm)) )
#define vcvtm_s32_f32(Dm)                        ( __neon_DdDm( 0xf3bb0300, (Dm)) )
#define vcvtm_u32_f32(Dm)                        ( __neon_DdDm( 0xf3bb0380, (Dm)) )
#define vcvtn_s32_f32(Dm)                        ( __neon_DdDm( 0xf3bb0100, (Dm)) )
#define vcvtn_u32_f32(Dm)                        ( __neon_DdDm( 0xf3bb0180, (Dm)) )
#define vcvtp_s32_f32(Dm)                        ( __neon_DdDm( 0xf3bb0200, (Dm)) )
#define vcvtp_u32_f32(Dm)                        ( __neon_DdDm( 0xf3bb0280, (Dm)) )
#define vcvtaq_s32_f32(Qm)                       ( __neon_QdQm( 0xf3bb0040, (Qm)) )
#define vcvtaq_u32_f32(Qm)                       ( __neon_QdQm( 0xf3bb00c0, (Qm)) )
#define vcvtmq_s32_f32(Qm)                       ( __neon_QdQm( 0xf3bb0340, (Qm)) )
#define vcvtmq_u32_f32(Qm)                       ( __neon_QdQm( 0xf3bb03c0, (Qm)) )
#define vcvtnq_s32_f32(Qm)                       ( __neon_QdQm( 0xf3bb0140, (Qm)) )
#define vcvtnq_u32_f32(Qm)                       ( __neon_QdQm( 0xf3bb01c0, (Qm)) )
#define vcvtpq_s32_f32(Qm)                       ( __neon_QdQm( 0xf3bb0240, (Qm)) )
#define vcvtpq_u32_f32(Qm)                       ( __neon_QdQm( 0xf3bb02c0, (Qm)) )

// VCVT (between floating-point and integer)
#define vcvt_f32_s32(Dm)                         ( __neon_DdDm( 0xf3bb0600, (Dm)) )
#define vcvt_f32_u32(Dm)                         ( __neon_DdDm( 0xf3bb0680, (Dm)) )
#define vcvt_s32_f32(Dm)                         ( __neon_DdDm( 0xf3bb0700, (Dm)) )
#define vcvt_u32_f32(Dm)                         ( __neon_DdDm( 0xf3bb0780, (Dm)) )
#define vcvtq_f32_s32(Qm)                        ( __neon_QdQm( 0xf3bb0640, (Qm)) )
#define vcvtq_f32_u32(Qm)                        ( __neon_QdQm( 0xf3bb06c0, (Qm)) )
#define vcvtq_s32_f32(Qm)                        ( __neon_QdQm( 0xf3bb0740, (Qm)) )
#define vcvtq_u32_f32(Qm)                        ( __neon_QdQm( 0xf3bb07c0, (Qm)) )

// VDUP (scalar)
#define vdup_lane_f32(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDm( 0xf3b40c00 | _NENC_19(lane), (Dm)) )
#define vdup_lane_p16(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDm( 0xf3b20c00 | _NENC_19_18(lane), (Dm)) )
#define vdup_lane_p8(Dm, lane)                   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdDm( 0xf3b10c00 | _NENC_19_17(lane), (Dm)) )
#define vdup_lane_s16(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDm( 0xf3b20c00 | _NENC_19_18(lane), (Dm)) )
#define vdup_lane_s32(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDm( 0xf3b40c00 | _NENC_19(lane), (Dm)) )
#define vdup_lane_s8(Dm, lane)                   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdDm( 0xf3b10c00 | _NENC_19_17(lane), (Dm)) )
#define vdup_lane_u16(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDm( 0xf3b20c00 | _NENC_19_18(lane), (Dm)) )
#define vdup_lane_u32(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDm( 0xf3b40c00 | _NENC_19(lane), (Dm)) )
#define vdup_lane_u8(Dm, lane)                   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdDm( 0xf3b10c00 | _NENC_19_17(lane), (Dm)) )
#define vdupq_lane_f32(Dm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDm( 0xf3b40c40 | _NENC_19(lane), (Dm)) )
#define vdupq_lane_p16(Dm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDm( 0xf3b20c40 | _NENC_19_18(lane), (Dm)) )
#define vdupq_lane_p8(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdDm( 0xf3b10c40 | _NENC_19_17(lane), (Dm)) )
#define vdupq_lane_s16(Dm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDm( 0xf3b20c40 | _NENC_19_18(lane), (Dm)) )
#define vdupq_lane_s32(Dm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDm( 0xf3b40c40 | _NENC_19(lane), (Dm)) )
#define vdupq_lane_s8(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdDm( 0xf3b10c40 | _NENC_19_17(lane), (Dm)) )
#define vdupq_lane_u16(Dm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDm( 0xf3b20c40 | _NENC_19_18(lane), (Dm)) )
#define vdupq_lane_u32(Dm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDm( 0xf3b40c40 | _NENC_19(lane), (Dm)) )
#define vdupq_lane_u8(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdDm( 0xf3b10c40 | _NENC_19_17(lane), (Dm)) )

// VDUP, VMOV (ARM core register to Neon register)
#define vdup_n_f32(Ft)                           ( __neon_DdFt( 0xee800b10, (Ft)) )
#define vmov_n_f32(Ft)                           ( __neon_DdFt( 0xee800b10, (Ft)) )
#define vdup_n_p16(Rt)                           ( __neon_DdRt( 0xee800b30, __poly16ToInt32(Rt)) )
#define vdup_n_p8(Rt)                            ( __neon_DdRt( 0xeec00b10, __poly8ToInt32(Rt)) )
#define vdup_n_s16(Rt)                           ( __neon_DdRt( 0xee800b30, __int16ToInt32(Rt)) )
#define vdup_n_s32(Rt)                           ( __neon_DdRt( 0xee800b10, __int32ToInt32(Rt)) )
#define vdup_n_s8(Rt)                            ( __neon_DdRt( 0xeec00b10, __int8ToInt32(Rt)) )
#define vdup_n_u16(Rt)                           ( __neon_DdRt( 0xee800b30, __uint16ToInt32(Rt)) )
#define vdup_n_u32(Rt)                           ( __neon_DdRt( 0xee800b10, __uint32ToInt32(Rt)) )
#define vdup_n_u8(Rt)                            ( __neon_DdRt( 0xeec00b10, __uint8ToInt32(Rt)) )
#define vmov_n_p16(Rt)                           ( __neon_DdRt( 0xee800b30, __poly16ToInt32(Rt)) )
#define vmov_n_p8(Rt)                            ( __neon_DdRt( 0xeec00b10, __poly8ToInt32(Rt)) )
#define vmov_n_s16(Rt)                           ( __neon_DdRt( 0xee800b30, __int16ToInt32(Rt)) )
#define vmov_n_s32(Rt)                           ( __neon_DdRt( 0xee800b10, __int32ToInt32(Rt)) )
#define vmov_n_s8(Rt)                            ( __neon_DdRt( 0xeec00b10, __int8ToInt32(Rt)) )
#define vmov_n_u16(Rt)                           ( __neon_DdRt( 0xee800b30, __uint16ToInt32(Rt)) )
#define vmov_n_u32(Rt)                           ( __neon_DdRt( 0xee800b10, __uint32ToInt32(Rt)) )
#define vmov_n_u8(Rt)                            ( __neon_DdRt( 0xeec00b10, __uint8ToInt32(Rt)) )
#define vdupq_n_f32(Ft)                          ( __neon_QdFt( 0xeea00b10, (Ft)) )
#define vmovq_n_f32(Ft)                          ( __neon_QdFt( 0xeea00b10, (Ft)) )
#define vdupq_n_p16(Rt)                          ( __neon_QdRt( 0xeea00b30, __poly16ToInt32(Rt)) )
#define vdupq_n_p8(Rt)                           ( __neon_QdRt( 0xeee00b10, __poly8ToInt32(Rt)) )
#define vdupq_n_s16(Rt)                          ( __neon_QdRt( 0xeea00b30, __int16ToInt32(Rt)) )
#define vdupq_n_s32(Rt)                          ( __neon_QdRt( 0xeea00b10, __int32ToInt32(Rt)) )
#define vdupq_n_s8(Rt)                           ( __neon_QdRt( 0xeee00b10, __int8ToInt32(Rt)) )
#define vdupq_n_u16(Rt)                          ( __neon_QdRt( 0xeea00b30, __uint16ToInt32(Rt)) )
#define vdupq_n_u32(Rt)                          ( __neon_QdRt( 0xeea00b10, __uint32ToInt32(Rt)) )
#define vdupq_n_u8(Rt)                           ( __neon_QdRt( 0xeee00b10, __uint8ToInt32(Rt)) )
#define vmovq_n_p16(Rt)                          ( __neon_QdRt( 0xeea00b30, __poly16ToInt32(Rt)) )
#define vmovq_n_p8(Rt)                           ( __neon_QdRt( 0xeee00b10, __poly8ToInt32(Rt)) )
#define vmovq_n_s16(Rt)                          ( __neon_QdRt( 0xeea00b30, __int16ToInt32(Rt)) )
#define vmovq_n_s32(Rt)                          ( __neon_QdRt( 0xeea00b10, __int32ToInt32(Rt)) )
#define vmovq_n_s8(Rt)                           ( __neon_QdRt( 0xeee00b10, __int8ToInt32(Rt)) )
#define vmovq_n_u16(Rt)                          ( __neon_QdRt( 0xeea00b30, __uint16ToInt32(Rt)) )
#define vmovq_n_u32(Rt)                          ( __neon_QdRt( 0xeea00b10, __uint32ToInt32(Rt)) )
#define vmovq_n_u8(Rt)                           ( __neon_QdRt( 0xeee00b10, __uint8ToInt32(Rt)) )

// VDUP.64, VMOV.64 (ARM core register pair to Neon registers)
#define vdup_n_s64(R64t)                         ( __neon_DdRtRt2( 0xec400b10, __int64ToInt64(R64t)) )
#define vdup_n_u64(R64t)                         ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vmov_n_s64(R64t)                         ( __neon_DdRtRt2( 0xec400b10, __int64ToInt64(R64t)) )
#define vmov_n_u64(R64t)                         ( __neon_DdRtRt2( 0xec400b10, __uint64ToInt64(R64t)) )
#define vdupq_n_s64(R64t)                        ( __neon_QdRtRt2_dup( 0xec400b10, __int64ToInt64(R64t)) )
#define vdupq_n_u64(R64t)                        ( __neon_QdRtRt2_dup( 0xec400b10, __uint64ToInt64(R64t)) )
#define vmovq_n_s64(R64t)                        ( __neon_QdRtRt2_dup( 0xec400b10, __int64ToInt64(R64t)) )
#define vmovq_n_u64(R64t)                        ( __neon_QdRtRt2_dup( 0xec400b10, __uint64ToInt64(R64t)) )

// VEOR, VBIC, VORN
#define vbic_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100110, (Dn), (Dm)) )
#define vbic_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100110, (Dn), (Dm)) )
#define vbic_s64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100110, (Dn), (Dm)) )
#define vbic_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2100110, (Dn), (Dm)) )
#define vbic_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100110, (Dn), (Dm)) )
#define vbic_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100110, (Dn), (Dm)) )
#define vbic_u64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100110, (Dn), (Dm)) )
#define vbic_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2100110, (Dn), (Dm)) )
#define veor_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000110, (Dn), (Dm)) )
#define veor_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000110, (Dn), (Dm)) )
#define veor_s64(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000110, (Dn), (Dm)) )
#define veor_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000110, (Dn), (Dm)) )
#define veor_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000110, (Dn), (Dm)) )
#define veor_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000110, (Dn), (Dm)) )
#define veor_u64(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000110, (Dn), (Dm)) )
#define veor_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000110, (Dn), (Dm)) )
#define vorn_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300110, (Dn), (Dm)) )
#define vorn_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300110, (Dn), (Dm)) )
#define vorn_s64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300110, (Dn), (Dm)) )
#define vorn_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2300110, (Dn), (Dm)) )
#define vorn_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300110, (Dn), (Dm)) )
#define vorn_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300110, (Dn), (Dm)) )
#define vorn_u64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300110, (Dn), (Dm)) )
#define vorn_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2300110, (Dn), (Dm)) )
#define vbicq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100150, (Qn), (Qm)) )
#define vbicq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100150, (Qn), (Qm)) )
#define vbicq_s64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100150, (Qn), (Qm)) )
#define vbicq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2100150, (Qn), (Qm)) )
#define vbicq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100150, (Qn), (Qm)) )
#define vbicq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100150, (Qn), (Qm)) )
#define vbicq_u64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100150, (Qn), (Qm)) )
#define vbicq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2100150, (Qn), (Qm)) )
#define veorq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000150, (Qn), (Qm)) )
#define veorq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000150, (Qn), (Qm)) )
#define veorq_s64(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000150, (Qn), (Qm)) )
#define veorq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000150, (Qn), (Qm)) )
#define veorq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000150, (Qn), (Qm)) )
#define veorq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000150, (Qn), (Qm)) )
#define veorq_u64(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000150, (Qn), (Qm)) )
#define veorq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000150, (Qn), (Qm)) )
#define vornq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300150, (Qn), (Qm)) )
#define vornq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300150, (Qn), (Qm)) )
#define vornq_s64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300150, (Qn), (Qm)) )
#define vornq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2300150, (Qn), (Qm)) )
#define vornq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300150, (Qn), (Qm)) )
#define vornq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300150, (Qn), (Qm)) )
#define vornq_u64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300150, (Qn), (Qm)) )
#define vornq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2300150, (Qn), (Qm)) )

// VEXT
#define vext_f32(Dn, Dm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 2, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 4), (Dn), (Dm)) )
#define vext_p16(Dn, Dm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 4, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 2), (Dn), (Dm)) )
#define vext_p8(Dn, Dm, pos)                     ( __static_assert((pos) >= 0 && (pos) < 8, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8(pos), (Dn), (Dm)) )
#define vext_s16(Dn, Dm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 4, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 2), (Dn), (Dm)) )
#define vext_s32(Dn, Dm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 2, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 4), (Dn), (Dm)) )
#define vext_s64(Dn, Dm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 1, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 8), (Dn), (Dm)) )
#define vext_s8(Dn, Dm, pos)                     ( __static_assert((pos) >= 0 && (pos) < 8, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8(pos), (Dn), (Dm)) )
#define vext_u16(Dn, Dm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 4, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 2), (Dn), (Dm)) )
#define vext_u32(Dn, Dm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 2, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 4), (Dn), (Dm)) )
#define vext_u64(Dn, Dm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 1, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 8), (Dn), (Dm)) )
#define vext_u8(Dn, Dm, pos)                     ( __static_assert((pos) >= 0 && (pos) < 8, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8(pos), (Dn), (Dm)) )
#define vextq_f32(Qn, Qm, pos)                   ( __static_assert((pos) >= 0 && (pos) < 4, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 4), (Qn), (Qm)) )
#define vextq_p16(Qn, Qm, pos)                   ( __static_assert((pos) >= 0 && (pos) < 8, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 2), (Qn), (Qm)) )
#define vextq_p8(Qn, Qm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 16, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8(pos), (Qn), (Qm)) )
#define vextq_s16(Qn, Qm, pos)                   ( __static_assert((pos) >= 0 && (pos) < 8, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 2), (Qn), (Qm)) )
#define vextq_s32(Qn, Qm, pos)                   ( __static_assert((pos) >= 0 && (pos) < 4, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 4), (Qn), (Qm)) )
#define vextq_s64(Qn, Qm, pos)                   ( __static_assert((pos) >= 0 && (pos) < 2, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 8), (Qn), (Qm)) )
#define vextq_s8(Qn, Qm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 16, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8(pos), (Qn), (Qm)) )
#define vextq_u16(Qn, Qm, pos)                   ( __static_assert((pos) >= 0 && (pos) < 8, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 2), (Qn), (Qm)) )
#define vextq_u32(Qn, Qm, pos)                   ( __static_assert((pos) >= 0 && (pos) < 4, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 4), (Qn), (Qm)) )
#define vextq_u64(Qn, Qm, pos)                   ( __static_assert((pos) >= 0 && (pos) < 2, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 8), (Qn), (Qm)) )
#define vextq_u8(Qn, Qm, pos)                    ( __static_assert((pos) >= 0 && (pos) < 16, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8(pos), (Qn), (Qm)) )

// VGET (access the 64bit high/low part of a 128bit register)
#define vget_high_f32(Qm)                        ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_p16(Qm)                        ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_p8(Qm)                         ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_s16(Qm)                        ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_s32(Qm)                        ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_s64(Qm)                        ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_s8(Qm)                         ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_u16(Qm)                        ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_u32(Qm)                        ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_u64(Qm)                        ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_high_u8(Qm)                         ( __neon_DdQm_high( 0x00000000, (Qm)) )
#define vget_low_f32(Qm)                         ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_p16(Qm)                         ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_p8(Qm)                          ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_s16(Qm)                         ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_s32(Qm)                         ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_s64(Qm)                         ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_s8(Qm)                          ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_u16(Qm)                         ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_u32(Qm)                         ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_u64(Qm)                         ( __neon_DdQm_low( 0x00000000, (Qm)) )
#define vget_low_u8(Qm)                          ( __neon_DdQm_low( 0x00000000, (Qm)) )

// VHADD, VRHADD, VHSUB
#define vhadd_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100000, (Dn), (Dm)) )
#define vhadd_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200000, (Dn), (Dm)) )
#define vhadd_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000000, (Dn), (Dm)) )
#define vhadd_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf3100000, (Dn), (Dm)) )
#define vhadd_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200000, (Dn), (Dm)) )
#define vhadd_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000000, (Dn), (Dm)) )
#define vhsub_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100200, (Dn), (Dm)) )
#define vhsub_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200200, (Dn), (Dm)) )
#define vhsub_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000200, (Dn), (Dm)) )
#define vhsub_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf3100200, (Dn), (Dm)) )
#define vhsub_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200200, (Dn), (Dm)) )
#define vhsub_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000200, (Dn), (Dm)) )
#define vrhadd_s16(Dn, Dm)                       ( __neon_DdDnDm( 0xf2100100, (Dn), (Dm)) )
#define vrhadd_s32(Dn, Dm)                       ( __neon_DdDnDm( 0xf2200100, (Dn), (Dm)) )
#define vrhadd_s8(Dn, Dm)                        ( __neon_DdDnDm( 0xf2000100, (Dn), (Dm)) )
#define vrhadd_u16(Dn, Dm)                       ( __neon_DdDnDm( 0xf3100100, (Dn), (Dm)) )
#define vrhadd_u32(Dn, Dm)                       ( __neon_DdDnDm( 0xf3200100, (Dn), (Dm)) )
#define vrhadd_u8(Dn, Dm)                        ( __neon_DdDnDm( 0xf3000100, (Dn), (Dm)) )
#define vhaddq_s16(Qn, Qm)                       ( __neon_QdQnQm( 0xf2100040, (Qn), (Qm)) )
#define vhaddq_s32(Qn, Qm)                       ( __neon_QdQnQm( 0xf2200040, (Qn), (Qm)) )
#define vhaddq_s8(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000040, (Qn), (Qm)) )
#define vhaddq_u16(Qn, Qm)                       ( __neon_QdQnQm( 0xf3100040, (Qn), (Qm)) )
#define vhaddq_u32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3200040, (Qn), (Qm)) )
#define vhaddq_u8(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000040, (Qn), (Qm)) )
#define vhsubq_s16(Qn, Qm)                       ( __neon_QdQnQm( 0xf2100240, (Qn), (Qm)) )
#define vhsubq_s32(Qn, Qm)                       ( __neon_QdQnQm( 0xf2200240, (Qn), (Qm)) )
#define vhsubq_s8(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000240, (Qn), (Qm)) )
#define vhsubq_u16(Qn, Qm)                       ( __neon_QdQnQm( 0xf3100240, (Qn), (Qm)) )
#define vhsubq_u32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3200240, (Qn), (Qm)) )
#define vhsubq_u8(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000240, (Qn), (Qm)) )
#define vrhaddq_s16(Qn, Qm)                      ( __neon_QdQnQm( 0xf2100140, (Qn), (Qm)) )
#define vrhaddq_s32(Qn, Qm)                      ( __neon_QdQnQm( 0xf2200140, (Qn), (Qm)) )
#define vrhaddq_s8(Qn, Qm)                       ( __neon_QdQnQm( 0xf2000140, (Qn), (Qm)) )
#define vrhaddq_u16(Qn, Qm)                      ( __neon_QdQnQm( 0xf3100140, (Qn), (Qm)) )
#define vrhaddq_u32(Qn, Qm)                      ( __neon_QdQnQm( 0xf3200140, (Qn), (Qm)) )
#define vrhaddq_u8(Qn, Qm)                       ( __neon_QdQnQm( 0xf3000140, (Qn), (Qm)) )

// VLD1 (multiple single elements)
#define vld1_f32(pcD)                            ( __neon_D1Adr( 0xf420078f, __float32ToN64_c(pcD)) )
#define vld1_p16(pcD)                            ( __neon_D1Adr( 0xf420074f, __poly16ToN64_c(pcD)) )
#define vld1_p8(pcD)                             ( __neon_D1Adr( 0xf420070f, __poly8ToN64_c(pcD)) )
#define vld1_s16(pcD)                            ( __neon_D1Adr( 0xf420074f, __int16ToN64_c(pcD)) )
#define vld1_s32(pcD)                            ( __neon_D1Adr( 0xf420078f, __int32ToN64_c(pcD)) )
#define vld1_s64(pcD)                            ( __neon_D1Adr( 0xf42007cf, __int64ToN64_c(pcD)) )
#define vld1_s8(pcD)                             ( __neon_D1Adr( 0xf420070f, __int8ToN64_c(pcD)) )
#define vld1_u16(pcD)                            ( __neon_D1Adr( 0xf420074f, __uint16ToN64_c(pcD)) )
#define vld1_u32(pcD)                            ( __neon_D1Adr( 0xf420078f, __uint32ToN64_c(pcD)) )
#define vld1_u64(pcD)                            ( __neon_D1Adr( 0xf42007cf, __uint64ToN64_c(pcD)) )
#define vld1_u8(pcD)                             ( __neon_D1Adr( 0xf420070f, __uint8ToN64_c(pcD)) )
#define vld1_f32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420078f | _NENC_5_4(_NEON_ALIGN64(align)), __float32ToN64_c(pcD)) )
#define vld1_p16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420074f | _NENC_5_4(_NEON_ALIGN64(align)), __poly16ToN64_c(pcD)) )
#define vld1_p8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420070f | _NENC_5_4(_NEON_ALIGN64(align)), __poly8ToN64_c(pcD)) )
#define vld1_s16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420074f | _NENC_5_4(_NEON_ALIGN64(align)), __int16ToN64_c(pcD)) )
#define vld1_s32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420078f | _NENC_5_4(_NEON_ALIGN64(align)), __int32ToN64_c(pcD)) )
#define vld1_s64_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf42007cf | _NENC_5_4(_NEON_ALIGN64(align)), __int64ToN64_c(pcD)) )
#define vld1_s8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420070f | _NENC_5_4(_NEON_ALIGN64(align)), __int8ToN64_c(pcD)) )
#define vld1_u16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420074f | _NENC_5_4(_NEON_ALIGN64(align)), __uint16ToN64_c(pcD)) )
#define vld1_u32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420078f | _NENC_5_4(_NEON_ALIGN64(align)), __uint32ToN64_c(pcD)) )
#define vld1_u64_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf42007cf | _NENC_5_4(_NEON_ALIGN64(align)), __uint64ToN64_c(pcD)) )
#define vld1_u8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420070f | _NENC_5_4(_NEON_ALIGN64(align)), __uint8ToN64_c(pcD)) )
#define vld1q_f32(pcD)                           ( __neon_Q1Adr( 0xf4200a8f, __float32ToN64_c(pcD)) )
#define vld1q_p16(pcD)                           ( __neon_Q1Adr( 0xf4200a4f, __poly16ToN64_c(pcD)) )
#define vld1q_p8(pcD)                            ( __neon_Q1Adr( 0xf4200a0f, __poly8ToN64_c(pcD)) )
#define vld1q_s16(pcD)                           ( __neon_Q1Adr( 0xf4200a4f, __int16ToN64_c(pcD)) )
#define vld1q_s32(pcD)                           ( __neon_Q1Adr( 0xf4200a8f, __int32ToN64_c(pcD)) )
#define vld1q_s64(pcD)                           ( __neon_Q1Adr( 0xf4200acf, __int64ToN64_c(pcD)) )
#define vld1q_s8(pcD)                            ( __neon_Q1Adr( 0xf4200a0f, __int8ToN64_c(pcD)) )
#define vld1q_u16(pcD)                           ( __neon_Q1Adr( 0xf4200a4f, __uint16ToN64_c(pcD)) )
#define vld1q_u32(pcD)                           ( __neon_Q1Adr( 0xf4200a8f, __uint32ToN64_c(pcD)) )
#define vld1q_u64(pcD)                           ( __neon_Q1Adr( 0xf4200acf, __uint64ToN64_c(pcD)) )
#define vld1q_u8(pcD)                            ( __neon_Q1Adr( 0xf4200a0f, __uint8ToN64_c(pcD)) )
#define vld1q_f32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64_c(pcD)) )
#define vld1q_p16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64_c(pcD)) )
#define vld1q_p8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64_c(pcD)) )
#define vld1q_s16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64_c(pcD)) )
#define vld1q_s32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64_c(pcD)) )
#define vld1q_s64_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64_c(pcD)) )
#define vld1q_s8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64_c(pcD)) )
#define vld1q_u16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64_c(pcD)) )
#define vld1q_u32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64_c(pcD)) )
#define vld1q_u64_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64_c(pcD)) )
#define vld1q_u8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64_c(pcD)) )

// VLD1 (single element to all lanes)
#define vld1_dup_f32(pcD)                        ( __neon_D1Adr( 0xf4a00c8f, __float32ToN64_c(pcD)) )
#define vld1_dup_p16(pcD)                        ( __neon_D1Adr( 0xf4a00c4f, __poly16ToN64_c(pcD)) )
#define vld1_dup_p8(pcD)                         ( __neon_D1Adr( 0xf4a00c0f, __poly8ToN64_c(pcD)) )
#define vld1_dup_s16(pcD)                        ( __neon_D1Adr( 0xf4a00c4f, __int16ToN64_c(pcD)) )
#define vld1_dup_s32(pcD)                        ( __neon_D1Adr( 0xf4a00c8f, __int32ToN64_c(pcD)) )
#define vld1_dup_s8(pcD)                         ( __neon_D1Adr( 0xf4a00c0f, __int8ToN64_c(pcD)) )
#define vld1_dup_u16(pcD)                        ( __neon_D1Adr( 0xf4a00c4f, __uint16ToN64_c(pcD)) )
#define vld1_dup_u32(pcD)                        ( __neon_D1Adr( 0xf4a00c8f, __uint32ToN64_c(pcD)) )
#define vld1_dup_u8(pcD)                         ( __neon_D1Adr( 0xf4a00c0f, __uint8ToN64_c(pcD)) )
#define vld1q_dup_f32(pcD)                       ( __neon_Q1Adr( 0xf4a00caf, __float32ToN64_c(pcD)) )
#define vld1q_dup_p16(pcD)                       ( __neon_Q1Adr( 0xf4a00c6f, __poly16ToN64_c(pcD)) )
#define vld1q_dup_p8(pcD)                        ( __neon_Q1Adr( 0xf4a00c2f, __poly8ToN64_c(pcD)) )
#define vld1q_dup_s16(pcD)                       ( __neon_Q1Adr( 0xf4a00c6f, __int16ToN64_c(pcD)) )
#define vld1q_dup_s32(pcD)                       ( __neon_Q1Adr( 0xf4a00caf, __int32ToN64_c(pcD)) )
#define vld1q_dup_s8(pcD)                        ( __neon_Q1Adr( 0xf4a00c2f, __int8ToN64_c(pcD)) )
#define vld1q_dup_u16(pcD)                       ( __neon_Q1Adr( 0xf4a00c6f, __uint16ToN64_c(pcD)) )
#define vld1q_dup_u32(pcD)                       ( __neon_Q1Adr( 0xf4a00caf, __uint32ToN64_c(pcD)) )
#define vld1q_dup_u8(pcD)                        ( __neon_Q1Adr( 0xf4a00c2f, __uint8ToN64_c(pcD)) )

// VLD1 (single element to all lanes, aligned)
#define vld1_dup_f32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c8f | _NENC_4(_NEON_ALIGN32(align)), __float32ToN64_c(pcD)) )
#define vld1_dup_p16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c4f | _NENC_4(_NEON_ALIGN16(align)), __poly16ToN64_c(pcD)) )
#define vld1_dup_s16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c4f | _NENC_4(_NEON_ALIGN16(align)), __int16ToN64_c(pcD)) )
#define vld1_dup_s32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c8f | _NENC_4(_NEON_ALIGN32(align)), __int32ToN64_c(pcD)) )
#define vld1_dup_u16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c4f | _NENC_4(_NEON_ALIGN16(align)), __uint16ToN64_c(pcD)) )
#define vld1_dup_u32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c8f | _NENC_4(_NEON_ALIGN32(align)), __uint32ToN64_c(pcD)) )
#define vld1q_dup_f32_ex(pcD, align)             ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00caf | _NENC_4(_NEON_ALIGN32(align)), __float32ToN64_c(pcD)) )
#define vld1q_dup_p16_ex(pcD, align)             ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00c6f | _NENC_4(_NEON_ALIGN16(align)), __poly16ToN64_c(pcD)) )
#define vld1q_dup_s16_ex(pcD, align)             ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00c6f | _NENC_4(_NEON_ALIGN16(align)), __int16ToN64_c(pcD)) )
#define vld1q_dup_s32_ex(pcD, align)             ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00caf | _NENC_4(_NEON_ALIGN32(align)), __int32ToN64_c(pcD)) )
#define vld1q_dup_u16_ex(pcD, align)             ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00c6f | _NENC_4(_NEON_ALIGN16(align)), __uint16ToN64_c(pcD)) )
#define vld1q_dup_u32_ex(pcD, align)             ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00caf | _NENC_4(_NEON_ALIGN32(align)), __uint32ToN64_c(pcD)) )

// VLD1 (single element to one lane)
#define vld1_lane_f32(pcD, Dd, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane), (Dd), __float32ToN64_c(pcD)) )
#define vld1_lane_p16(pcD, Dd, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane), (Dd), __poly16ToN64_c(pcD)) )
#define vld1_lane_p8(pcD, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0000f | _NENC_7_5(lane), (Dd), __poly8ToN64_c(pcD)) )
#define vld1_lane_s16(pcD, Dd, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane), (Dd), __int16ToN64_c(pcD)) )
#define vld1_lane_s32(pcD, Dd, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane), (Dd), __int32ToN64_c(pcD)) )
#define vld1_lane_s8(pcD, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0000f | _NENC_7_5(lane), (Dd), __int8ToN64_c(pcD)) )
#define vld1_lane_u16(pcD, Dd, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane), (Dd), __uint16ToN64_c(pcD)) )
#define vld1_lane_u32(pcD, Dd, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane), (Dd), __uint32ToN64_c(pcD)) )
#define vld1_lane_u8(pcD, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0000f | _NENC_7_5(lane), (Dd), __uint8ToN64_c(pcD)) )
#define vld1q_lane_f32(pcD, Qd, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Qd), __float32ToN64_c(pcD)) )
#define vld1q_lane_p16(pcD, Qd, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Qd), __poly16ToN64_c(pcD)) )
#define vld1q_lane_p8(pcD, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), (Qd), __poly8ToN64_c(pcD)) )
#define vld1q_lane_s16(pcD, Qd, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Qd), __int16ToN64_c(pcD)) )
#define vld1q_lane_s32(pcD, Qd, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Qd), __int32ToN64_c(pcD)) )
#define vld1q_lane_s8(pcD, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), (Qd), __int8ToN64_c(pcD)) )
#define vld1q_lane_u16(pcD, Qd, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Qd), __uint16ToN64_c(pcD)) )
#define vld1q_lane_u32(pcD, Qd, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Qd), __uint32ToN64_c(pcD)) )
#define vld1q_lane_u8(pcD, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), (Qd), __uint8ToN64_c(pcD)) )

// VLD1 (single element to one lane, aligned)
#define vld1_lane_f32_ex(pcD, Dd, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Dd), __float32ToN64_c(pcD)) )
#define vld1_lane_p16_ex(pcD, Dd, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), (Dd), __poly16ToN64_c(pcD)) )
#define vld1_lane_s16_ex(pcD, Dd, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), (Dd), __int16ToN64_c(pcD)) )
#define vld1_lane_s32_ex(pcD, Dd, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Dd), __int32ToN64_c(pcD)) )
#define vld1_lane_u16_ex(pcD, Dd, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), (Dd), __uint16ToN64_c(pcD)) )
#define vld1_lane_u32_ex(pcD, Dd, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Dd), __uint32ToN64_c(pcD)) )
#define vld1q_lane_f32_ex(pcD, Qd, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Qd), __float32ToN64_c(pcD)) )
#define vld1q_lane_p16_ex(pcD, Qd, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), (Qd), __poly16ToN64_c(pcD)) )
#define vld1q_lane_s16_ex(pcD, Qd, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), (Qd), __int16ToN64_c(pcD)) )
#define vld1q_lane_s32_ex(pcD, Qd, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Qd), __int32ToN64_c(pcD)) )
#define vld1q_lane_u16_ex(pcD, Qd, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), (Qd), __uint16ToN64_c(pcD)) )
#define vld1q_lane_u32_ex(pcD, Qd, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Qd), __uint32ToN64_c(pcD)) )

// VLD2 (multiple 2-element structures)
#define vld2_f32(pcD)                            ( __neon_Dx2Adr( 0xf420088f, __float32ToN64_c(pcD)) )
#define vld2_p16(pcD)                            ( __neon_Dx2Adr( 0xf420084f, __poly16ToN64_c(pcD)) )
#define vld2_p8(pcD)                             ( __neon_Dx2Adr( 0xf420080f, __poly8ToN64_c(pcD)) )
#define vld2_s16(pcD)                            ( __neon_Dx2Adr( 0xf420084f, __int16ToN64_c(pcD)) )
#define vld2_s32(pcD)                            ( __neon_Dx2Adr( 0xf420088f, __int32ToN64_c(pcD)) )
#define vld2_s8(pcD)                             ( __neon_Dx2Adr( 0xf420080f, __int8ToN64_c(pcD)) )
#define vld2_u16(pcD)                            ( __neon_Dx2Adr( 0xf420084f, __uint16ToN64_c(pcD)) )
#define vld2_u32(pcD)                            ( __neon_Dx2Adr( 0xf420088f, __uint32ToN64_c(pcD)) )
#define vld2_u8(pcD)                             ( __neon_Dx2Adr( 0xf420080f, __uint8ToN64_c(pcD)) )
#define vld2_s64(pcD)                            ( __neon_Dx2Adr( 0xf4200acf, __int64ToN64_c(pcD)) )
#define vld2_u64(pcD)                            ( __neon_Dx2Adr( 0xf4200acf, __uint64ToN64_c(pcD)) )
#define vld2_s64_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64_c(pcD)) )
#define vld2_u64_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64_c(pcD)) )
#define vld2_f32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64_c(pcD)) )
#define vld2_p16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64_c(pcD)) )
#define vld2_p8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64_c(pcD)) )
#define vld2_s16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64_c(pcD)) )
#define vld2_s32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64_c(pcD)) )
#define vld2_s8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64_c(pcD)) )
#define vld2_u16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64_c(pcD)) )
#define vld2_u32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64_c(pcD)) )
#define vld2_u8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64_c(pcD)) )
#define vld2q_f32(pcD)                           ( __neon_Qx2Adr( 0xf420098f, __float32ToN64_c(pcD)) )
#define vld2q_p16(pcD)                           ( __neon_Qx2Adr( 0xf420094f, __poly16ToN64_c(pcD)) )
#define vld2q_p8(pcD)                            ( __neon_Qx2Adr( 0xf420090f, __poly8ToN64_c(pcD)) )
#define vld2q_s16(pcD)                           ( __neon_Qx2Adr( 0xf420094f, __int16ToN64_c(pcD)) )
#define vld2q_s32(pcD)                           ( __neon_Qx2Adr( 0xf420098f, __int32ToN64_c(pcD)) )
#define vld2q_s8(pcD)                            ( __neon_Qx2Adr( 0xf420090f, __int8ToN64_c(pcD)) )
#define vld2q_u16(pcD)                           ( __neon_Qx2Adr( 0xf420094f, __uint16ToN64_c(pcD)) )
#define vld2q_u32(pcD)                           ( __neon_Qx2Adr( 0xf420098f, __uint32ToN64_c(pcD)) )
#define vld2q_u8(pcD)                            ( __neon_Qx2Adr( 0xf420090f, __uint8ToN64_c(pcD)) )
#define vld2q_f32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64_c(pcD)) )
#define vld2q_p16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64_c(pcD)) )
#define vld2q_p8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64_c(pcD)) )
#define vld2q_s16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64_c(pcD)) )
#define vld2q_s32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64_c(pcD)) )
#define vld2q_s8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64_c(pcD)) )
#define vld2q_u16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64_c(pcD)) )
#define vld2q_u32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64_c(pcD)) )
#define vld2q_u8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64_c(pcD)) )

// VLD2 (single 2-element structure to all lanes)
#define vld2_dup_f32(pcD)                        ( __neon_Dx2Adr( 0xf4a00d8f, __float32ToN64_c(pcD)) )
#define vld2_dup_p16(pcD)                        ( __neon_Dx2Adr( 0xf4a00d4f, __poly16ToN64_c(pcD)) )
#define vld2_dup_p8(pcD)                         ( __neon_Dx2Adr( 0xf4a00d0f, __poly8ToN64_c(pcD)) )
#define vld2_dup_s16(pcD)                        ( __neon_Dx2Adr( 0xf4a00d4f, __int16ToN64_c(pcD)) )
#define vld2_dup_s32(pcD)                        ( __neon_Dx2Adr( 0xf4a00d8f, __int32ToN64_c(pcD)) )
#define vld2_dup_s8(pcD)                         ( __neon_Dx2Adr( 0xf4a00d0f, __int8ToN64_c(pcD)) )
#define vld2_dup_u16(pcD)                        ( __neon_Dx2Adr( 0xf4a00d4f, __uint16ToN64_c(pcD)) )
#define vld2_dup_u32(pcD)                        ( __neon_Dx2Adr( 0xf4a00d8f, __uint32ToN64_c(pcD)) )
#define vld2_dup_u8(pcD)                         ( __neon_Dx2Adr( 0xf4a00d0f, __uint8ToN64_c(pcD)) )
#define vld2_dup_s64(pcD)                        ( __neon_Dx2Adr( 0xf4200acf, __int64ToN64_c(pcD)) )
#define vld2_dup_u64(pcD)                        ( __neon_Dx2Adr( 0xf4200acf, __uint64ToN64_c(pcD)) )

// VLD2 (single 2-element structure to all lanes, aligned)
#define vld2_dup_s64_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64_c(pcD)) )
#define vld2_dup_u64_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64_c(pcD)) )
#define vld2_dup_f32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d8f | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64_c(pcD)) )
#define vld2_dup_p16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d4f | _NENC_4(_NEON_ALIGN32(align)), __poly16ToN64_c(pcD)) )
#define vld2_dup_p8_ex(pcD, align)               ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d0f | _NENC_4(_NEON_ALIGN16(align)), __poly8ToN64_c(pcD)) )
#define vld2_dup_s16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d4f | _NENC_4(_NEON_ALIGN32(align)), __int16ToN64_c(pcD)) )
#define vld2_dup_s32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d8f | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64_c(pcD)) )
#define vld2_dup_s8_ex(pcD, align)               ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d0f | _NENC_4(_NEON_ALIGN16(align)), __int8ToN64_c(pcD)) )
#define vld2_dup_u16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d4f | _NENC_4(_NEON_ALIGN32(align)), __uint16ToN64_c(pcD)) )
#define vld2_dup_u32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d8f | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64_c(pcD)) )
#define vld2_dup_u8_ex(pcD, align)               ( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d0f | _NENC_4(_NEON_ALIGN16(align)), __uint8ToN64_c(pcD)) )

// VLD2 (single 2-element structure to one lane)
#define vld2_lane_f32(pcD, D2, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane), (D2), __float32ToN64_c(pcD)) )
#define vld2_lane_p16(pcD, D2, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane), (D2), __poly16ToN64_c(pcD)) )
#define vld2_lane_p8(pcD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane), (D2), __poly8ToN64_c(pcD)) )
#define vld2_lane_s16(pcD, D2, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane), (D2), __int16ToN64_c(pcD)) )
#define vld2_lane_s32(pcD, D2, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane), (D2), __int32ToN64_c(pcD)) )
#define vld2_lane_s8(pcD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane), (D2), __int8ToN64_c(pcD)) )
#define vld2_lane_u16(pcD, D2, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane), (D2), __uint16ToN64_c(pcD)) )
#define vld2_lane_u32(pcD, D2, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane), (D2), __uint32ToN64_c(pcD)) )
#define vld2_lane_u8(pcD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane), (D2), __uint8ToN64_c(pcD)) )
#define vld2q_lane_f32(pcD, Q2, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q2), __float32ToN64_c(pcD)) )
#define vld2q_lane_p16(pcD, Q2, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q2), __poly16ToN64_c(pcD)) )
#define vld2q_lane_s16(pcD, Q2, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q2), __int16ToN64_c(pcD)) )
#define vld2q_lane_s32(pcD, Q2, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q2), __int32ToN64_c(pcD)) )
#define vld2q_lane_u16(pcD, Q2, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q2), __uint16ToN64_c(pcD)) )
#define vld2q_lane_u32(pcD, Q2, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q2), __uint32ToN64_c(pcD)) )

// VLD2 (single 2-element structure to one lane, aligned)
#define vld2_lane_f32_ex(pcD, D2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), (D2), __float32ToN64_c(pcD)) )
#define vld2_lane_p16_ex(pcD, D2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), (D2), __poly16ToN64_c(pcD)) )
#define vld2_lane_p8_ex(pcD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), (D2), __poly8ToN64_c(pcD)) )
#define vld2_lane_s16_ex(pcD, D2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), (D2), __int16ToN64_c(pcD)) )
#define vld2_lane_s32_ex(pcD, D2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), (D2), __int32ToN64_c(pcD)) )
#define vld2_lane_s8_ex(pcD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), (D2), __int8ToN64_c(pcD)) )
#define vld2_lane_u16_ex(pcD, D2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), (D2), __uint16ToN64_c(pcD)) )
#define vld2_lane_u32_ex(pcD, D2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), (D2), __uint32ToN64_c(pcD)) )
#define vld2_lane_u8_ex(pcD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), (D2), __uint8ToN64_c(pcD)) )
#define vld2q_lane_f32_ex(pcD, Q2, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q2), __float32ToN64_c(pcD)) )
#define vld2q_lane_p16_ex(pcD, Q2, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), (Q2), __poly16ToN64_c(pcD)) )
#define vld2q_lane_s16_ex(pcD, Q2, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), (Q2), __int16ToN64_c(pcD)) )
#define vld2q_lane_s32_ex(pcD, Q2, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q2), __int32ToN64_c(pcD)) )
#define vld2q_lane_u16_ex(pcD, Q2, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), (Q2), __uint16ToN64_c(pcD)) )
#define vld2q_lane_u32_ex(pcD, Q2, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q2), __uint32ToN64_c(pcD)) )

// VLD3 (multiple 3-element structures)
#define vld3_f32(pcD)                            ( __neon_Dx3Adr( 0xf420048f, __float32ToN64_c(pcD)) )
#define vld3_p16(pcD)                            ( __neon_Dx3Adr( 0xf420044f, __poly16ToN64_c(pcD)) )
#define vld3_p8(pcD)                             ( __neon_Dx3Adr( 0xf420040f, __poly8ToN64_c(pcD)) )
#define vld3_s16(pcD)                            ( __neon_Dx3Adr( 0xf420044f, __int16ToN64_c(pcD)) )
#define vld3_s32(pcD)                            ( __neon_Dx3Adr( 0xf420048f, __int32ToN64_c(pcD)) )
#define vld3_s8(pcD)                             ( __neon_Dx3Adr( 0xf420040f, __int8ToN64_c(pcD)) )
#define vld3_u16(pcD)                            ( __neon_Dx3Adr( 0xf420044f, __uint16ToN64_c(pcD)) )
#define vld3_u32(pcD)                            ( __neon_Dx3Adr( 0xf420048f, __uint32ToN64_c(pcD)) )
#define vld3_u8(pcD)                             ( __neon_Dx3Adr( 0xf420040f, __uint8ToN64_c(pcD)) )
#define vld3_s64(pcD)                            ( __neon_Dx3Adr( 0xf42006cf, __int64ToN64_c(pcD)) )
#define vld3_u64(pcD)                            ( __neon_Dx3Adr( 0xf42006cf, __uint64ToN64_c(pcD)) )
#define vld3_s64_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf42006cf | _NENC_5_4(_NEON_ALIGN64(align)), __int64ToN64_c(pcD)) )
#define vld3_u64_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf42006cf | _NENC_5_4(_NEON_ALIGN64(align)), __uint64ToN64_c(pcD)) )
#define vld3_f32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420048f | _NENC_5_4(_NEON_ALIGN64(align)), __float32ToN64_c(pcD)) )
#define vld3_p16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420044f | _NENC_5_4(_NEON_ALIGN64(align)), __poly16ToN64_c(pcD)) )
#define vld3_p8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420040f | _NENC_5_4(_NEON_ALIGN64(align)), __poly8ToN64_c(pcD)) )
#define vld3_s16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420044f | _NENC_5_4(_NEON_ALIGN64(align)), __int16ToN64_c(pcD)) )
#define vld3_s32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420048f | _NENC_5_4(_NEON_ALIGN64(align)), __int32ToN64_c(pcD)) )
#define vld3_s8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420040f | _NENC_5_4(_NEON_ALIGN64(align)), __int8ToN64_c(pcD)) )
#define vld3_u16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420044f | _NENC_5_4(_NEON_ALIGN64(align)), __uint16ToN64_c(pcD)) )
#define vld3_u32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420048f | _NENC_5_4(_NEON_ALIGN64(align)), __uint32ToN64_c(pcD)) )
#define vld3_u8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420040f | _NENC_5_4(_NEON_ALIGN64(align)), __uint8ToN64_c(pcD)) )
#define vld3q_f32(pcD)                           ( __neon_Qx3Adr( 0xf420058f, __float32ToN64_c(pcD)) )
#define vld3q_p16(pcD)                           ( __neon_Qx3Adr( 0xf420054f, __poly16ToN64_c(pcD)) )
#define vld3q_p8(pcD)                            ( __neon_Qx3Adr( 0xf420050f, __poly8ToN64_c(pcD)) )
#define vld3q_s16(pcD)                           ( __neon_Qx3Adr( 0xf420054f, __int16ToN64_c(pcD)) )
#define vld3q_s32(pcD)                           ( __neon_Qx3Adr( 0xf420058f, __int32ToN64_c(pcD)) )
#define vld3q_s8(pcD)                            ( __neon_Qx3Adr( 0xf420050f, __int8ToN64_c(pcD)) )
#define vld3q_u16(pcD)                           ( __neon_Qx3Adr( 0xf420054f, __uint16ToN64_c(pcD)) )
#define vld3q_u32(pcD)                           ( __neon_Qx3Adr( 0xf420058f, __uint32ToN64_c(pcD)) )
#define vld3q_u8(pcD)                            ( __neon_Qx3Adr( 0xf420050f, __uint8ToN64_c(pcD)) )
#define vld3q_f32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420058f | _NENC_5_4(_NEON_ALIGN64(align)), __float32ToN64_c(pcD)) )
#define vld3q_p16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420054f | _NENC_5_4(_NEON_ALIGN64(align)), __poly16ToN64_c(pcD)) )
#define vld3q_p8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420050f | _NENC_5_4(_NEON_ALIGN64(align)), __poly8ToN64_c(pcD)) )
#define vld3q_s16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420054f | _NENC_5_4(_NEON_ALIGN64(align)), __int16ToN64_c(pcD)) )
#define vld3q_s32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420058f | _NENC_5_4(_NEON_ALIGN64(align)), __int32ToN64_c(pcD)) )
#define vld3q_s8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420050f | _NENC_5_4(_NEON_ALIGN64(align)), __int8ToN64_c(pcD)) )
#define vld3q_u16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420054f | _NENC_5_4(_NEON_ALIGN64(align)), __uint16ToN64_c(pcD)) )
#define vld3q_u32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420058f | _NENC_5_4(_NEON_ALIGN64(align)), __uint32ToN64_c(pcD)) )
#define vld3q_u8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420050f | _NENC_5_4(_NEON_ALIGN64(align)), __uint8ToN64_c(pcD)) )

// VLD3 (single 3-element structure to all lanes)
#define vld3_dup_f32(pcD)                        ( __neon_Dx3Adr( 0xf4a00e8f, __float32ToN64_c(pcD)) )
#define vld3_dup_p16(pcD)                        ( __neon_Dx3Adr( 0xf4a00e4f, __poly16ToN64_c(pcD)) )
#define vld3_dup_p8(pcD)                         ( __neon_Dx3Adr( 0xf4a00e0f, __poly8ToN64_c(pcD)) )
#define vld3_dup_s16(pcD)                        ( __neon_Dx3Adr( 0xf4a00e4f, __int16ToN64_c(pcD)) )
#define vld3_dup_s32(pcD)                        ( __neon_Dx3Adr( 0xf4a00e8f, __int32ToN64_c(pcD)) )
#define vld3_dup_s8(pcD)                         ( __neon_Dx3Adr( 0xf4a00e0f, __int8ToN64_c(pcD)) )
#define vld3_dup_u16(pcD)                        ( __neon_Dx3Adr( 0xf4a00e4f, __uint16ToN64_c(pcD)) )
#define vld3_dup_u32(pcD)                        ( __neon_Dx3Adr( 0xf4a00e8f, __uint32ToN64_c(pcD)) )
#define vld3_dup_u8(pcD)                         ( __neon_Dx3Adr( 0xf4a00e0f, __uint8ToN64_c(pcD)) )
#define vld3_dup_s64(pcD)                        ( __neon_Dx3Adr( 0xf42006cf, __int64ToN64_c(pcD)) )
#define vld3_dup_u64(pcD)                        ( __neon_Dx3Adr( 0xf42006cf, __uint64ToN64_c(pcD)) )

// VLD3 (single 3-element structure to one lane)
#define vld3_lane_f32(pcD, D3, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a00a0f | _NENC_7(lane), (D3), __float32ToN64_c(pcD)) )
#define vld3_lane_p16(pcD, D3, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0060f | _NENC_7_6(lane), (D3), __poly16ToN64_c(pcD)) )
#define vld3_lane_p8(pcD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0020f | _NENC_7_5(lane), (D3), __poly8ToN64_c(pcD)) )
#define vld3_lane_s16(pcD, D3, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0060f | _NENC_7_6(lane), (D3), __int16ToN64_c(pcD)) )
#define vld3_lane_s32(pcD, D3, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a00a0f | _NENC_7(lane), (D3), __int32ToN64_c(pcD)) )
#define vld3_lane_s8(pcD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0020f | _NENC_7_5(lane), (D3), __int8ToN64_c(pcD)) )
#define vld3_lane_u16(pcD, D3, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0060f | _NENC_7_6(lane), (D3), __uint16ToN64_c(pcD)) )
#define vld3_lane_u32(pcD, D3, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a00a0f | _NENC_7(lane), (D3), __uint32ToN64_c(pcD)) )
#define vld3_lane_u8(pcD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0020f | _NENC_7_5(lane), (D3), __uint8ToN64_c(pcD)) )
#define vld3q_lane_f32(pcD, Q3, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a00a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q3), __float32ToN64_c(pcD)) )
#define vld3q_lane_p16(pcD, Q3, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a0062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q3), __poly16ToN64_c(pcD)) )
#define vld3q_lane_s16(pcD, Q3, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a0062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q3), __int16ToN64_c(pcD)) )
#define vld3q_lane_s32(pcD, Q3, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a00a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q3), __int32ToN64_c(pcD)) )
#define vld3q_lane_u16(pcD, Q3, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a0062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q3), __uint16ToN64_c(pcD)) )
#define vld3q_lane_u32(pcD, Q3, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a00a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q3), __uint32ToN64_c(pcD)) )

// VLD4 (multiple 4-element structures)
#define vld4_f32(pcD)                            ( __neon_Dx4Adr( 0xf420008f, __float32ToN64_c(pcD)) )
#define vld4_p16(pcD)                            ( __neon_Dx4Adr( 0xf420004f, __poly16ToN64_c(pcD)) )
#define vld4_p8(pcD)                             ( __neon_Dx4Adr( 0xf420000f, __poly8ToN64_c(pcD)) )
#define vld4_s16(pcD)                            ( __neon_Dx4Adr( 0xf420004f, __int16ToN64_c(pcD)) )
#define vld4_s32(pcD)                            ( __neon_Dx4Adr( 0xf420008f, __int32ToN64_c(pcD)) )
#define vld4_s8(pcD)                             ( __neon_Dx4Adr( 0xf420000f, __int8ToN64_c(pcD)) )
#define vld4_u16(pcD)                            ( __neon_Dx4Adr( 0xf420004f, __uint16ToN64_c(pcD)) )
#define vld4_u32(pcD)                            ( __neon_Dx4Adr( 0xf420008f, __uint32ToN64_c(pcD)) )
#define vld4_u8(pcD)                             ( __neon_Dx4Adr( 0xf420000f, __uint8ToN64_c(pcD)) )
#define vld4_s64(pcD)                            ( __neon_Dx4Adr( 0xf42002cf, __int64ToN64_c(pcD)) )
#define vld4_u64(pcD)                            ( __neon_Dx4Adr( 0xf42002cf, __uint64ToN64_c(pcD)) )
#define vld4_s64_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf42002cf | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int64ToN64_c(pcD)) )
#define vld4_u64_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf42002cf | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint64ToN64_c(pcD)) )
#define vld4_f32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __float32ToN64_c(pcD)) )
#define vld4_p16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly16ToN64_c(pcD)) )
#define vld4_p8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly8ToN64_c(pcD)) )
#define vld4_s16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int16ToN64_c(pcD)) )
#define vld4_s32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int32ToN64_c(pcD)) )
#define vld4_s8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int8ToN64_c(pcD)) )
#define vld4_u16_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint16ToN64_c(pcD)) )
#define vld4_u32_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint32ToN64_c(pcD)) )
#define vld4_u8_ex(pcD, align)                   ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint8ToN64_c(pcD)) )
#define vld4q_f32(pcD)                           ( __neon_Qx4Adr( 0xf420018f, __float32ToN64_c(pcD)) )
#define vld4q_p16(pcD)                           ( __neon_Qx4Adr( 0xf420014f, __poly16ToN64_c(pcD)) )
#define vld4q_p8(pcD)                            ( __neon_Qx4Adr( 0xf420010f, __poly8ToN64_c(pcD)) )
#define vld4q_s16(pcD)                           ( __neon_Qx4Adr( 0xf420014f, __int16ToN64_c(pcD)) )
#define vld4q_s32(pcD)                           ( __neon_Qx4Adr( 0xf420018f, __int32ToN64_c(pcD)) )
#define vld4q_s8(pcD)                            ( __neon_Qx4Adr( 0xf420010f, __int8ToN64_c(pcD)) )
#define vld4q_u16(pcD)                           ( __neon_Qx4Adr( 0xf420014f, __uint16ToN64_c(pcD)) )
#define vld4q_u32(pcD)                           ( __neon_Qx4Adr( 0xf420018f, __uint32ToN64_c(pcD)) )
#define vld4q_u8(pcD)                            ( __neon_Qx4Adr( 0xf420010f, __uint8ToN64_c(pcD)) )
#define vld4q_f32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __float32ToN64_c(pcD)) )
#define vld4q_p16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly16ToN64_c(pcD)) )
#define vld4q_p8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly8ToN64_c(pcD)) )
#define vld4q_s16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int16ToN64_c(pcD)) )
#define vld4q_s32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int32ToN64_c(pcD)) )
#define vld4q_s8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int8ToN64_c(pcD)) )
#define vld4q_u16_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint16ToN64_c(pcD)) )
#define vld4q_u32_ex(pcD, align)                 ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint32ToN64_c(pcD)) )
#define vld4q_u8_ex(pcD, align)                  ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint8ToN64_c(pcD)) )

// VLD4 (single 4-element structure to all lanes)
#define vld4_dup_f32(pcD)                        ( __neon_Dx4Adr( 0xf4a00f8f, __float32ToN64_c(pcD)) )
#define vld4_dup_p16(pcD)                        ( __neon_Dx4Adr( 0xf4a00f4f, __poly16ToN64_c(pcD)) )
#define vld4_dup_p8(pcD)                         ( __neon_Dx4Adr( 0xf4a00f0f, __poly8ToN64_c(pcD)) )
#define vld4_dup_s16(pcD)                        ( __neon_Dx4Adr( 0xf4a00f4f, __int16ToN64_c(pcD)) )
#define vld4_dup_s32(pcD)                        ( __neon_Dx4Adr( 0xf4a00f8f, __int32ToN64_c(pcD)) )
#define vld4_dup_s8(pcD)                         ( __neon_Dx4Adr( 0xf4a00f0f, __int8ToN64_c(pcD)) )
#define vld4_dup_u16(pcD)                        ( __neon_Dx4Adr( 0xf4a00f4f, __uint16ToN64_c(pcD)) )
#define vld4_dup_u32(pcD)                        ( __neon_Dx4Adr( 0xf4a00f8f, __uint32ToN64_c(pcD)) )
#define vld4_dup_u8(pcD)                         ( __neon_Dx4Adr( 0xf4a00f0f, __uint8ToN64_c(pcD)) )
#define vld4_dup_s64(pcD)                        ( __neon_Dx4Adr( 0xf42002cf, __int64ToN64_c(pcD)) )
#define vld4_dup_u64(pcD)                        ( __neon_Dx4Adr( 0xf42002cf, __uint64ToN64_c(pcD)) )

// VLD4 (single 4-element structure to all lanes, aligned)
#define vld4_dup_f32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_7_6(_NEON_ALIGN64_128(align) > 1 ? 3 : 2) | _NENC_4(_NEON_ALIGN64_128(align) > 0 ? 1 : 0), __float32ToN64_c(pcD)) )
#define vld4_dup_p16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f4f | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64_c(pcD)) )
#define vld4_dup_p8_ex(pcD, align)               ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_4(_NEON_ALIGN32(align)), __poly8ToN64_c(pcD)) )
#define vld4_dup_s16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f4f | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64_c(pcD)) )
#define vld4_dup_s32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_7_6(_NEON_ALIGN64_128(align) > 1 ? 3 : 2) | _NENC_4(_NEON_ALIGN64_128(align) > 0 ? 1 : 0), __int32ToN64_c(pcD)) )
#define vld4_dup_s8_ex(pcD, align)               ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_4(_NEON_ALIGN32(align)), __int8ToN64_c(pcD)) )
#define vld4_dup_u16_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f4f | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64_c(pcD)) )
#define vld4_dup_u32_ex(pcD, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_7_6(_NEON_ALIGN64_128(align) > 1 ? 3 : 2) | _NENC_4(_NEON_ALIGN64_128(align) > 0 ? 1 : 0), __uint32ToN64_c(pcD)) )
#define vld4_dup_u8_ex(pcD, align)               ( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_4(_NEON_ALIGN32(align)), __uint8ToN64_c(pcD)) )

// VLD4 (single 4-element structure to one lane)
#define vld4_lane_f32(pcD, D4, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane), (D4), __float32ToN64_c(pcD)) )
#define vld4_lane_p16(pcD, D4, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane), (D4), __poly16ToN64_c(pcD)) )
#define vld4_lane_p8(pcD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane), (D4), __poly8ToN64_c(pcD)) )
#define vld4_lane_s16(pcD, D4, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane), (D4), __int16ToN64_c(pcD)) )
#define vld4_lane_s32(pcD, D4, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane), (D4), __int32ToN64_c(pcD)) )
#define vld4_lane_s8(pcD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane), (D4), __int8ToN64_c(pcD)) )
#define vld4_lane_u16(pcD, D4, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane), (D4), __uint16ToN64_c(pcD)) )
#define vld4_lane_u32(pcD, D4, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane), (D4), __uint32ToN64_c(pcD)) )
#define vld4_lane_u8(pcD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane), (D4), __uint8ToN64_c(pcD)) )
#define vld4q_lane_f32(pcD, Q4, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q4), __float32ToN64_c(pcD)) )
#define vld4q_lane_p16(pcD, Q4, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q4), __poly16ToN64_c(pcD)) )
#define vld4q_lane_s16(pcD, Q4, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q4), __int16ToN64_c(pcD)) )
#define vld4q_lane_s32(pcD, Q4, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q4), __int32ToN64_c(pcD)) )
#define vld4q_lane_u16(pcD, Q4, lane)            ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q4), __uint16ToN64_c(pcD)) )
#define vld4q_lane_u32(pcD, Q4, lane)            ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q4), __uint32ToN64_c(pcD)) )

// VLD4 (single 4-element structure to one lane, aligned)
#define vld4_lane_f32_ex(pcD, D4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), (D4), __float32ToN64_c(pcD)) )
#define vld4_lane_p16_ex(pcD, D4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), (D4), __poly16ToN64_c(pcD)) )
#define vld4_lane_p8_ex(pcD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), (D4), __poly8ToN64_c(pcD)) )
#define vld4_lane_s16_ex(pcD, D4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), (D4), __int16ToN64_c(pcD)) )
#define vld4_lane_s32_ex(pcD, D4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), (D4), __int32ToN64_c(pcD)) )
#define vld4_lane_s8_ex(pcD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), (D4), __int8ToN64_c(pcD)) )
#define vld4_lane_u16_ex(pcD, D4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), (D4), __uint16ToN64_c(pcD)) )
#define vld4_lane_u32_ex(pcD, D4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), (D4), __uint32ToN64_c(pcD)) )
#define vld4_lane_u8_ex(pcD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), (D4), __uint8ToN64_c(pcD)) )
#define vld4q_lane_f32_ex(pcD, Q4, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), (Q4), __float32ToN64_c(pcD)) )
#define vld4q_lane_p16_ex(pcD, Q4, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q4), __poly16ToN64_c(pcD)) )
#define vld4q_lane_s16_ex(pcD, Q4, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q4), __int16ToN64_c(pcD)) )
#define vld4q_lane_s32_ex(pcD, Q4, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), (Q4), __int32ToN64_c(pcD)) )
#define vld4q_lane_u16_ex(pcD, Q4, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q4), __uint16ToN64_c(pcD)) )
#define vld4q_lane_u32_ex(pcD, Q4, lane, align)  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), (Q4), __uint32ToN64_c(pcD)) )

// VMAX, VMIN (floating point)
#define vmax_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000f00, (Dn), (Dm)) )
#define vmaxnm_f32(Dn, Dm)                       ( __neon_DdDnDm( 0xf3000f10, (Dn), (Dm)) )
#define vmin_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200f00, (Dn), (Dm)) )
#define vminnm_f32(Dn, Dm)                       ( __neon_DdDnDm( 0xf3200f10, (Dn), (Dm)) )
#define vmaxq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000f40, (Qn), (Qm)) )
#define vmaxnmq_f32(Qn, Qm)                      ( __neon_QdQnQm( 0xf3000f50, (Qn), (Qm)) )
#define vminq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200f40, (Qn), (Qm)) )
#define vminnmq_f32(Qn, Qm)                      ( __neon_QdQnQm( 0xf3200f50, (Qn), (Qm)) )

// VMAX, VMIN (integer)
#define vmax_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100600, (Dn), (Dm)) )
#define vmax_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200600, (Dn), (Dm)) )
#define vmax_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000600, (Dn), (Dm)) )
#define vmax_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100600, (Dn), (Dm)) )
#define vmax_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200600, (Dn), (Dm)) )
#define vmax_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000600, (Dn), (Dm)) )
#define vmin_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100610, (Dn), (Dm)) )
#define vmin_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200610, (Dn), (Dm)) )
#define vmin_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000610, (Dn), (Dm)) )
#define vmin_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100610, (Dn), (Dm)) )
#define vmin_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200610, (Dn), (Dm)) )
#define vmin_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000610, (Dn), (Dm)) )
#define vmaxq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100640, (Qn), (Qm)) )
#define vmaxq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200640, (Qn), (Qm)) )
#define vmaxq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000640, (Qn), (Qm)) )
#define vmaxq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100640, (Qn), (Qm)) )
#define vmaxq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200640, (Qn), (Qm)) )
#define vmaxq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000640, (Qn), (Qm)) )
#define vminq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100650, (Qn), (Qm)) )
#define vminq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200650, (Qn), (Qm)) )
#define vminq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000650, (Qn), (Qm)) )
#define vminq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100650, (Qn), (Qm)) )
#define vminq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200650, (Qn), (Qm)) )
#define vminq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000650, (Qn), (Qm)) )

// VMLA, VMLS (by scalar)
#define vmla_lane_f32(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00140 | _NENC_5(lane), (Dd), (Dn), (Dm)) )
#define vmla_lane_s16(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2900040 | _NENC_5x3(lane), (Dd), (Dn), (Dm)) )
#define vmla_lane_s32(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00040 | _NENC_5(lane), (Dd), (Dn), (Dm)) )
#define vmla_lane_u16(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2900040 | _NENC_5x3(lane), (Dd), (Dn), (Dm)) )
#define vmla_lane_u32(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00040 | _NENC_5(lane), (Dd), (Dn), (Dm)) )
#define vmls_lane_f32(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00540 | _NENC_5(lane), (Dd), (Dn), (Dm)) )
#define vmls_lane_s16(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2900440 | _NENC_5x3(lane), (Dd), (Dn), (Dm)) )
#define vmls_lane_s32(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00440 | _NENC_5(lane), (Dd), (Dn), (Dm)) )
#define vmls_lane_u16(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2900440 | _NENC_5x3(lane), (Dd), (Dn), (Dm)) )
#define vmls_lane_u32(Dd, Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00440 | _NENC_5(lane), (Dd), (Dn), (Dm)) )
#define vmlaq_lane_f32(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00140 | _NENC_5(lane), (Qd), (Qn), (Dm)) )
#define vmlaq_lane_s16(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3900040 | _NENC_5x3(lane), (Qd), (Qn), (Dm)) )
#define vmlaq_lane_s32(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00040 | _NENC_5(lane), (Qd), (Qn), (Dm)) )
#define vmlaq_lane_u16(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3900040 | _NENC_5x3(lane), (Qd), (Qn), (Dm)) )
#define vmlaq_lane_u32(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00040 | _NENC_5(lane), (Qd), (Qn), (Dm)) )
#define vmlsq_lane_f32(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00540 | _NENC_5(lane), (Qd), (Qn), (Dm)) )
#define vmlsq_lane_s16(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3900440 | _NENC_5x3(lane), (Qd), (Qn), (Dm)) )
#define vmlsq_lane_s32(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00440 | _NENC_5(lane), (Qd), (Qn), (Dm)) )
#define vmlsq_lane_u16(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3900440 | _NENC_5x3(lane), (Qd), (Qn), (Dm)) )
#define vmlsq_lane_u32(Qd, Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00440 | _NENC_5(lane), (Qd), (Qn), (Dm)) )

// VMLA, VMLS (float, by scalar)
#define vmla_n_f32(Dd, Dn, Ft)                   ( __neon_DdDnFt_acc( 0xf2a00140, (Dd), (Dn), (Ft)) )
#define vmls_n_f32(Dd, Dn, Ft)                   ( __neon_DdDnFt_acc( 0xf2a00540, (Dd), (Dn), (Ft)) )
#define vmlaq_n_f32(Qd, Qn, Ft)                  ( __neon_QdQnFt_acc( 0xf3a00140, (Qd), (Qn), (Ft)) )
#define vmlsq_n_f32(Qd, Qn, Ft)                  ( __neon_QdQnFt_acc( 0xf3a00540, (Qd), (Qn), (Ft)) )

// VMLA, VMLS (floating point)
#define vmla_f32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf2000d10, (Dd), (Dn), (Dm)) )
#define vmls_f32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf2200d10, (Dd), (Dn), (Dm)) )
#define vmlaq_f32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf2000d50, (Qd), (Qn), (Qm)) )
#define vmlsq_f32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf2200d50, (Qd), (Qn), (Qm)) )

// VMLA, VMLS (integer)
#define vmla_s16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf2100900, (Dd), (Dn), (Dm)) )
#define vmla_s32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf2200900, (Dd), (Dn), (Dm)) )
#define vmla_s8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf2000900, (Dd), (Dn), (Dm)) )
#define vmla_u16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf2100900, (Dd), (Dn), (Dm)) )
#define vmla_u32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf2200900, (Dd), (Dn), (Dm)) )
#define vmla_u8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf2000900, (Dd), (Dn), (Dm)) )
#define vmls_s16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100900, (Dd), (Dn), (Dm)) )
#define vmls_s32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200900, (Dd), (Dn), (Dm)) )
#define vmls_s8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3000900, (Dd), (Dn), (Dm)) )
#define vmls_u16(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3100900, (Dd), (Dn), (Dm)) )
#define vmls_u32(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3200900, (Dd), (Dn), (Dm)) )
#define vmls_u8(Dd, Dn, Dm)                      ( __neon_DdDnDm_acc( 0xf3000900, (Dd), (Dn), (Dm)) )
#define vmlaq_s16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf2100940, (Qd), (Qn), (Qm)) )
#define vmlaq_s32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf2200940, (Qd), (Qn), (Qm)) )
#define vmlaq_s8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf2000940, (Qd), (Qn), (Qm)) )
#define vmlaq_u16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf2100940, (Qd), (Qn), (Qm)) )
#define vmlaq_u32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf2200940, (Qd), (Qn), (Qm)) )
#define vmlaq_u8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf2000940, (Qd), (Qn), (Qm)) )
#define vmlsq_s16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100940, (Qd), (Qn), (Qm)) )
#define vmlsq_s32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200940, (Qd), (Qn), (Qm)) )
#define vmlsq_s8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3000940, (Qd), (Qn), (Qm)) )
#define vmlsq_u16(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3100940, (Qd), (Qn), (Qm)) )
#define vmlsq_u32(Qd, Qn, Qm)                    ( __neon_QdQnQm_acc( 0xf3200940, (Qd), (Qn), (Qm)) )
#define vmlsq_u8(Qd, Qn, Qm)                     ( __neon_QdQnQm_acc( 0xf3000940, (Qd), (Qn), (Qm)) )

// VMLAL, VMLSL
#define vmlal_s16(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf2900800, (Qd), (Dn), (Dm)) )
#define vmlal_s32(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf2a00800, (Qd), (Dn), (Dm)) )
#define vmlal_s8(Qd, Dn, Dm)                     ( __neon_QdDnDm_acc( 0xf2800800, (Qd), (Dn), (Dm)) )
#define vmlal_u16(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf3900800, (Qd), (Dn), (Dm)) )
#define vmlal_u32(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf3a00800, (Qd), (Dn), (Dm)) )
#define vmlal_u8(Qd, Dn, Dm)                     ( __neon_QdDnDm_acc( 0xf3800800, (Qd), (Dn), (Dm)) )
#define vmlsl_s16(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf2900a00, (Qd), (Dn), (Dm)) )
#define vmlsl_s32(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf2a00a00, (Qd), (Dn), (Dm)) )
#define vmlsl_s8(Qd, Dn, Dm)                     ( __neon_QdDnDm_acc( 0xf2800a00, (Qd), (Dn), (Dm)) )
#define vmlsl_u16(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf3900a00, (Qd), (Dn), (Dm)) )
#define vmlsl_u32(Qd, Dn, Dm)                    ( __neon_QdDnDm_acc( 0xf3a00a00, (Qd), (Dn), (Dm)) )
#define vmlsl_u8(Qd, Dn, Dm)                     ( __neon_QdDnDm_acc( 0xf3800a00, (Qd), (Dn), (Dm)) )

// VMLAL, VMLSL (by scalar)
#define vmlal_lane_s16(Qd, Dn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2900240 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )
#define vmlal_lane_s32(Qd, Dn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2a00240 | _NENC_5(lane), (Qd), (Dn), (Dm)) )
#define vmlal_lane_u16(Qd, Dn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf3900240 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )
#define vmlal_lane_u32(Qd, Dn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf3a00240 | _NENC_5(lane), (Qd), (Dn), (Dm)) )
#define vmlsl_lane_s16(Qd, Dn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2900640 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )
#define vmlsl_lane_s32(Qd, Dn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2a00640 | _NENC_5(lane), (Qd), (Dn), (Dm)) )
#define vmlsl_lane_u16(Qd, Dn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf3900640 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )
#define vmlsl_lane_u32(Qd, Dn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf3a00640 | _NENC_5(lane), (Qd), (Dn), (Dm)) )

// VMOV (ARM core register to scalar)
#define vset_lane_f32(Ft, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdFt_acc( 0xee000b10 | _NENC_21(lane), (Dd), (Ft)) )
#define vset_lane_p16(Rt, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdRt_acc( 0xee000b30 | _NENC_21x6(lane), (Dd), __poly16ToInt32(Rt)) )
#define vset_lane_p8(Rt, Dd, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdRt_acc( 0xee400b10 | _NENC_21x6_5(lane), (Dd), __poly8ToInt32(Rt)) )
#define vset_lane_s16(Rt, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdRt_acc( 0xee000b30 | _NENC_21x6(lane), (Dd), __int16ToInt32(Rt)) )
#define vset_lane_s32(Rt, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdRt_acc( 0xee000b10 | _NENC_21(lane), (Dd), __int32ToInt32(Rt)) )
#define vset_lane_s8(Rt, Dd, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdRt_acc( 0xee400b10 | _NENC_21x6_5(lane), (Dd), __int8ToInt32(Rt)) )
#define vset_lane_u16(Rt, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdRt_acc( 0xee000b30 | _NENC_21x6(lane), (Dd), __uint16ToInt32(Rt)) )
#define vset_lane_u32(Rt, Dd, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdRt_acc( 0xee000b10 | _NENC_21(lane), (Dd), __uint32ToInt32(Rt)) )
#define vset_lane_u8(Rt, Dd, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdRt_acc( 0xee400b10 | _NENC_21x6_5(lane), (Dd), __uint8ToInt32(Rt)) )

// VMOV (scalar to ARM core register)
#define vget_lane_f32(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_FtDn( 0xee100b10 | _NENC_21(lane), (Dm)) )
#define vget_lane_p16(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (poly16_t)__neon_RtDn( 0xee900b30 | _NENC_21x6(lane), (Dm)) )
#define vget_lane_p8(Dm, lane)                   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (poly8_t)__neon_RtDn( 0xeed00b10 | _NENC_21x6_5(lane), (Dm)) )
#define vget_lane_s16(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (int16_t)__neon_RtDn( 0xee100b30 | _NENC_21x6(lane), (Dm)) )
#define vget_lane_s8(Dm, lane)                   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (int8_t)__neon_RtDn( 0xee500b10 | _NENC_21x6_5(lane), (Dm)) )
#define vget_lane_s32(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), (int32_t)__neon_RtDn( 0xee100b10 | _NENC_21(lane), (Dm)) )
#define vget_lane_u16(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (uint16_t)__neon_RtDn( 0xee900b30 | _NENC_21x6(lane), (Dm)) )
#define vget_lane_u8(Dm, lane)                   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (uint8_t)__neon_RtDn( 0xeed00b10 | _NENC_21x6_5(lane), (Dm)) )
#define vget_lane_u32(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), (uint32_t)__neon_RtDn( 0xee100b10 | _NENC_21(lane), (Dm)) )

// VMOV.64 (ARM core register pair to scalar)
#define vset_lane_s64(R64t, Dd, lane)            ( __static_assert((lane) >= 0 && (lane) < 1, "invalid lane index"), __neon_DdRtRt2_acc( 0xec400b10, (Dd), __int64ToInt64(R64t)) )
#define vset_lane_u64(R64t, Dd, lane)            ( __static_assert((lane) >= 0 && (lane) < 1, "invalid lane index"), __neon_DdRtRt2_acc( 0xec400b10, (Dd), __uint64ToInt64(R64t)) )
#define vsetq_lane_s64(R64t, Qd, lane)           ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdRtRt2_acc( 0xec400b10 | _NENC_0(lane), (Qd), __int64ToInt64(R64t)) )
#define vsetq_lane_u64(R64t, Qd, lane)           ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdRtRt2_acc( 0xec400b10 | _NENC_0(lane), (Qd), __uint64ToInt64(R64t)) )

// VMOV.64 (scalar to ARM core register pair)
#define vget_lane_s64(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 1, "invalid lane index"), (int64_t)__neon_RtRt2Dm( 0xec500b10, (Dm)) )
#define vget_lane_u64(Dm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 1, "invalid lane index"), (uint64_t)__neon_RtRt2Dm( 0xec500b10, (Dm)) )
#define vgetq_lane_s64(Qm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), (int64_t)__neon_RtRt2Qm( 0xec500b10 | _NENC_0(lane), (Qm)) )
#define vgetq_lane_u64(Qm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), (uint64_t)__neon_RtRt2Qm( 0xec500b10 | _NENC_0(lane), (Qm)) )

// VMOV.Q (ARM core register to scalar)
#define vsetq_lane_f32(Ft, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdFt_acc( 0xee000b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qd), (Ft)) )
#define vsetq_lane_p16(Rt, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdRt_acc( 0xee000b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qd), __poly16ToInt32(Rt)) )
#define vsetq_lane_p8(Rt, Qd, lane)              ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_QdRt_acc( 0xee400b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qd), __poly8ToInt32(Rt)) )
#define vsetq_lane_s16(Rt, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdRt_acc( 0xee000b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qd), __int16ToInt32(Rt)) )
#define vsetq_lane_s32(Rt, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdRt_acc( 0xee000b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qd), __int32ToInt32(Rt)) )
#define vsetq_lane_s8(Rt, Qd, lane)              ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_QdRt_acc( 0xee400b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qd), __int8ToInt32(Rt)) )
#define vsetq_lane_u16(Rt, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdRt_acc( 0xee000b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qd), __uint16ToInt32(Rt)) )
#define vsetq_lane_u32(Rt, Qd, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdRt_acc( 0xee000b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qd), __uint32ToInt32(Rt)) )
#define vsetq_lane_u8(Rt, Qd, lane)              ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_QdRt_acc( 0xee400b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qd), __uint8ToInt32(Rt)) )

// VMOV.Q (scalar to ARM core register)
#define vgetq_lane_f32(Qm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_FtQn( 0xee100b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qm)) )
#define vgetq_lane_p16(Qm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (poly16_t)__neon_RtQn( 0xee900b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qm)) )
#define vgetq_lane_p8(Qm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), (poly8_t)__neon_RtQn( 0xeed00b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qm)) )
#define vgetq_lane_s16(Qm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (int16_t)__neon_RtQn( 0xee100b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qm)) )
#define vgetq_lane_s8(Qm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), (int8_t)__neon_RtQn( 0xee500b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qm)) )
#define vgetq_lane_s32(Qm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (int32_t)__neon_RtQn( 0xee100b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qm)) )
#define vgetq_lane_u16(Qm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (uint16_t)__neon_RtQn( 0xee900b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qm)) )
#define vgetq_lane_u8(Qm, lane)                  ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), (uint8_t)__neon_RtQn( 0xeed00b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qm)) )
#define vgetq_lane_u32(Qm, lane)                 ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (uint32_t)__neon_RtQn( 0xee100b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qm)) )

// VMOVL
#define vmovl_s16(Dm)                            ( __neon_QdDm( 0xf2900a10, (Dm)) )
#define vmovl_s32(Dm)                            ( __neon_QdDm( 0xf2a00a10, (Dm)) )
#define vmovl_s8(Dm)                             ( __neon_QdDm( 0xf2880a10, (Dm)) )
#define vmovl_u16(Dm)                            ( __neon_QdDm( 0xf3900a10, (Dm)) )
#define vmovl_u32(Dm)                            ( __neon_QdDm( 0xf3a00a10, (Dm)) )
#define vmovl_u8(Dm)                             ( __neon_QdDm( 0xf3880a10, (Dm)) )

// VMOVN
#define vmovn_s16(Qm)                            ( __neon_DdQm( 0xf3b20200, (Qm)) )
#define vmovn_s32(Qm)                            ( __neon_DdQm( 0xf3b60200, (Qm)) )
#define vmovn_s64(Qm)                            ( __neon_DdQm( 0xf3ba0200, (Qm)) )
#define vmovn_u16(Qm)                            ( __neon_DdQm( 0xf3b20200, (Qm)) )
#define vmovn_u32(Qm)                            ( __neon_DdQm( 0xf3b60200, (Qm)) )
#define vmovn_u64(Qm)                            ( __neon_DdQm( 0xf3ba0200, (Qm)) )

// VMUL
#define vmul_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000d10, (Dn), (Dm)) )
#define vmul_p8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000910, (Dn), (Dm)) )
#define vmul_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100910, (Dn), (Dm)) )
#define vmul_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200910, (Dn), (Dm)) )
#define vmul_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000910, (Dn), (Dm)) )
#define vmul_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100910, (Dn), (Dm)) )
#define vmul_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200910, (Dn), (Dm)) )
#define vmul_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000910, (Dn), (Dm)) )
#define vmulq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000d50, (Qn), (Qm)) )
#define vmulq_p8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000950, (Qn), (Qm)) )
#define vmulq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100950, (Qn), (Qm)) )
#define vmulq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200950, (Qn), (Qm)) )
#define vmulq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000950, (Qn), (Qm)) )
#define vmulq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100950, (Qn), (Qm)) )
#define vmulq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200950, (Qn), (Qm)) )
#define vmulq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000950, (Qn), (Qm)) )

// VMUL (by scalar - float)
#define vmul_n_f32(Dn, Ft)                       ( __neon_DdDnFt( 0xf2a00940, (Dn), (Ft)) )
#define vmulq_n_f32(Qn, Ft)                      ( __neon_QdQnFt( 0xf3a00940, (Qn), (Ft)) )

// VMUL (by scalar)
#define vmul_lane_f32(Dn, Dm, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00940 | _NENC_5(lane), (Dn), (Dm)) )
#define vmul_lane_s16(Dn, Dm, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx( 0xf2900840 | _NENC_5x3(lane), (Dn), (Dm)) )
#define vmul_lane_s32(Dn, Dm, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00840 | _NENC_5(lane), (Dn), (Dm)) )
#define vmul_lane_u16(Dn, Dm, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx( 0xf2900840 | _NENC_5x3(lane), (Dn), (Dm)) )
#define vmul_lane_u32(Dn, Dm, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00840 | _NENC_5(lane), (Dn), (Dm)) )
#define vmulq_lane_f32(Qn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00940 | _NENC_5(lane), (Qn), (Dm)) )
#define vmulq_lane_s16(Qn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx( 0xf3900840 | _NENC_5x3(lane), (Qn), (Dm)) )
#define vmulq_lane_s32(Qn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00840 | _NENC_5(lane), (Qn), (Dm)) )
#define vmulq_lane_u16(Qn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx( 0xf3900840 | _NENC_5x3(lane), (Qn), (Dm)) )
#define vmulq_lane_u32(Qn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00840 | _NENC_5(lane), (Qn), (Dm)) )

// VMULL
#define vmull_p64(Dn, Dm)                        ( __neon_QdDnDm( 0xf2a00e00, (Dn), (Dm)) )
#define vmull_p8(Dn, Dm)                         ( __neon_QdDnDm( 0xf2800e00, (Dn), (Dm)) )
#define vmull_s16(Dn, Dm)                        ( __neon_QdDnDm( 0xf2900c00, (Dn), (Dm)) )
#define vmull_s32(Dn, Dm)                        ( __neon_QdDnDm( 0xf2a00c00, (Dn), (Dm)) )
#define vmull_s8(Dn, Dm)                         ( __neon_QdDnDm( 0xf2800c00, (Dn), (Dm)) )
#define vmull_u16(Dn, Dm)                        ( __neon_QdDnDm( 0xf3900c00, (Dn), (Dm)) )
#define vmull_u32(Dn, Dm)                        ( __neon_QdDnDm( 0xf3a00c00, (Dn), (Dm)) )
#define vmull_u8(Dn, Dm)                         ( __neon_QdDnDm( 0xf3800c00, (Dn), (Dm)) )

// VMULL (by scalar)
#define vmull_lane_s16(Dn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx( 0xf2900a40 | _NENC_5x3(lane), (Dn), (Dm)) )
#define vmull_lane_s32(Dn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx( 0xf2a00a40 | _NENC_5(lane), (Dn), (Dm)) )
#define vmull_lane_u16(Dn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx( 0xf3900a40 | _NENC_5x3(lane), (Dn), (Dm)) )
#define vmull_lane_u32(Dn, Dm, lane)             ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx( 0xf3a00a40 | _NENC_5(lane), (Dn), (Dm)) )

// VMVN
#define vmvn_p16(Dm)                             ( __neon_DdDm( 0xf3b00580, (Dm)) )
#define vmvn_p8(Dm)                              ( __neon_DdDm( 0xf3b00580, (Dm)) )
#define vmvn_s16(Dm)                             ( __neon_DdDm( 0xf3b00580, (Dm)) )
#define vmvn_s32(Dm)                             ( __neon_DdDm( 0xf3b00580, (Dm)) )
#define vmvn_s8(Dm)                              ( __neon_DdDm( 0xf3b00580, (Dm)) )
#define vmvn_u16(Dm)                             ( __neon_DdDm( 0xf3b00580, (Dm)) )
#define vmvn_u32(Dm)                             ( __neon_DdDm( 0xf3b00580, (Dm)) )
#define vmvn_u8(Dm)                              ( __neon_DdDm( 0xf3b00580, (Dm)) )
#define vmvnq_p16(Qm)                            ( __neon_QdQm( 0xf3b005c0, (Qm)) )
#define vmvnq_p8(Qm)                             ( __neon_QdQm( 0xf3b005c0, (Qm)) )
#define vmvnq_s16(Qm)                            ( __neon_QdQm( 0xf3b005c0, (Qm)) )
#define vmvnq_s32(Qm)                            ( __neon_QdQm( 0xf3b005c0, (Qm)) )
#define vmvnq_s8(Qm)                             ( __neon_QdQm( 0xf3b005c0, (Qm)) )
#define vmvnq_u16(Qm)                            ( __neon_QdQm( 0xf3b005c0, (Qm)) )
#define vmvnq_u32(Qm)                            ( __neon_QdQm( 0xf3b005c0, (Qm)) )
#define vmvnq_u8(Qm)                             ( __neon_QdQm( 0xf3b005c0, (Qm)) )

// VPADAL
#define vpadal_s16(Dd, Dm)                       ( __neon_DdDm_acc( 0xf3b40600, (Dd), (Dm)) )
#define vpadal_s32(Dd, Dm)                       ( __neon_DdDm_acc( 0xf3b80600, (Dd), (Dm)) )
#define vpadal_s8(Dd, Dm)                        ( __neon_DdDm_acc( 0xf3b00600, (Dd), (Dm)) )
#define vpadal_u16(Dd, Dm)                       ( __neon_DdDm_acc( 0xf3b40680, (Dd), (Dm)) )
#define vpadal_u32(Dd, Dm)                       ( __neon_DdDm_acc( 0xf3b80680, (Dd), (Dm)) )
#define vpadal_u8(Dd, Dm)                        ( __neon_DdDm_acc( 0xf3b00680, (Dd), (Dm)) )
#define vpadalq_s16(Qd, Qm)                      ( __neon_QdQm_acc( 0xf3b40640, (Qd), (Qm)) )
#define vpadalq_s32(Qd, Qm)                      ( __neon_QdQm_acc( 0xf3b80640, (Qd), (Qm)) )
#define vpadalq_s8(Qd, Qm)                       ( __neon_QdQm_acc( 0xf3b00640, (Qd), (Qm)) )
#define vpadalq_u16(Qd, Qm)                      ( __neon_QdQm_acc( 0xf3b406c0, (Qd), (Qm)) )
#define vpadalq_u32(Qd, Qm)                      ( __neon_QdQm_acc( 0xf3b806c0, (Qd), (Qm)) )
#define vpadalq_u8(Qd, Qm)                       ( __neon_QdQm_acc( 0xf3b006c0, (Qd), (Qm)) )

// VPADD (floating point)
#define vpadd_f32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3000d00, (Dn), (Dm)) )

// VPADD (integer)
#define vpadd_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100b10, (Dn), (Dm)) )
#define vpadd_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200b10, (Dn), (Dm)) )
#define vpadd_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000b10, (Dn), (Dm)) )
#define vpadd_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100b10, (Dn), (Dm)) )
#define vpadd_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200b10, (Dn), (Dm)) )
#define vpadd_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000b10, (Dn), (Dm)) )

// VPADDL
#define vpaddl_s16(Dm)                           ( __neon_DdDm( 0xf3b40200, (Dm)) )
#define vpaddl_s32(Dm)                           ( __neon_DdDm( 0xf3b80200, (Dm)) )
#define vpaddl_s8(Dm)                            ( __neon_DdDm( 0xf3b00200, (Dm)) )
#define vpaddl_u16(Dm)                           ( __neon_DdDm( 0xf3b40280, (Dm)) )
#define vpaddl_u32(Dm)                           ( __neon_DdDm( 0xf3b80280, (Dm)) )
#define vpaddl_u8(Dm)                            ( __neon_DdDm( 0xf3b00280, (Dm)) )
#define vpaddlq_s16(Qm)                          ( __neon_QdQm( 0xf3b40240, (Qm)) )
#define vpaddlq_s32(Qm)                          ( __neon_QdQm( 0xf3b80240, (Qm)) )
#define vpaddlq_s8(Qm)                           ( __neon_QdQm( 0xf3b00240, (Qm)) )
#define vpaddlq_u16(Qm)                          ( __neon_QdQm( 0xf3b402c0, (Qm)) )
#define vpaddlq_u32(Qm)                          ( __neon_QdQm( 0xf3b802c0, (Qm)) )
#define vpaddlq_u8(Qm)                           ( __neon_QdQm( 0xf3b002c0, (Qm)) )

// VPMAX, VPMIN (floating point)
#define vpmax_f32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3000f00, (Dn), (Dm)) )
#define vpmin_f32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200f00, (Dn), (Dm)) )

// VPMAX, VPMIN (integer)
#define vpmax_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100a00, (Dn), (Dm)) )
#define vpmax_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200a00, (Dn), (Dm)) )
#define vpmax_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000a00, (Dn), (Dm)) )
#define vpmax_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf3100a00, (Dn), (Dm)) )
#define vpmax_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200a00, (Dn), (Dm)) )
#define vpmax_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000a00, (Dn), (Dm)) )
#define vpmin_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100a10, (Dn), (Dm)) )
#define vpmin_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200a10, (Dn), (Dm)) )
#define vpmin_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000a10, (Dn), (Dm)) )
#define vpmin_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf3100a10, (Dn), (Dm)) )
#define vpmin_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200a10, (Dn), (Dm)) )
#define vpmin_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000a10, (Dn), (Dm)) )

// VQABS, VQNEG
#define vqabs_s16(Dm)                            ( __neon_DdDm( 0xf3b40700, (Dm)) )
#define vqabs_s32(Dm)                            ( __neon_DdDm( 0xf3b80700, (Dm)) )
#define vqabs_s8(Dm)                             ( __neon_DdDm( 0xf3b00700, (Dm)) )
#define vqneg_s16(Dm)                            ( __neon_DdDm( 0xf3b40780, (Dm)) )
#define vqneg_s32(Dm)                            ( __neon_DdDm( 0xf3b80780, (Dm)) )
#define vqneg_s8(Dm)                             ( __neon_DdDm( 0xf3b00780, (Dm)) )
#define vqabsq_s16(Qm)                           ( __neon_QdQm( 0xf3b40740, (Qm)) )
#define vqabsq_s32(Qm)                           ( __neon_QdQm( 0xf3b80740, (Qm)) )
#define vqabsq_s8(Qm)                            ( __neon_QdQm( 0xf3b00740, (Qm)) )
#define vqnegq_s16(Qm)                           ( __neon_QdQm( 0xf3b407c0, (Qm)) )
#define vqnegq_s32(Qm)                           ( __neon_QdQm( 0xf3b807c0, (Qm)) )
#define vqnegq_s8(Qm)                            ( __neon_QdQm( 0xf3b007c0, (Qm)) )

// VQADD
#define vqadd_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100010, (Dn), (Dm)) )
#define vqadd_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200010, (Dn), (Dm)) )
#define vqadd_s64(Dn, Dm)                        ( __neon_DdDnDm( 0xf2300010, (Dn), (Dm)) )
#define vqadd_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000010, (Dn), (Dm)) )
#define vqadd_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf3100010, (Dn), (Dm)) )
#define vqadd_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200010, (Dn), (Dm)) )
#define vqadd_u64(Dn, Dm)                        ( __neon_DdDnDm( 0xf3300010, (Dn), (Dm)) )
#define vqadd_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000010, (Dn), (Dm)) )
#define vqaddq_s16(Qn, Qm)                       ( __neon_QdQnQm( 0xf2100050, (Qn), (Qm)) )
#define vqaddq_s32(Qn, Qm)                       ( __neon_QdQnQm( 0xf2200050, (Qn), (Qm)) )
#define vqaddq_s64(Qn, Qm)                       ( __neon_QdQnQm( 0xf2300050, (Qn), (Qm)) )
#define vqaddq_s8(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000050, (Qn), (Qm)) )
#define vqaddq_u16(Qn, Qm)                       ( __neon_QdQnQm( 0xf3100050, (Qn), (Qm)) )
#define vqaddq_u32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3200050, (Qn), (Qm)) )
#define vqaddq_u64(Qn, Qm)                       ( __neon_QdQnQm( 0xf3300050, (Qn), (Qm)) )
#define vqaddq_u8(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000050, (Qn), (Qm)) )

// VQDMLAL, VQDMLSL
#define vqdmlal_s16(Qd, Dn, Dm)                  ( __neon_QdDnDm_acc( 0xf2900900, (Qd), (Dn), (Dm)) )
#define vqdmlal_s32(Qd, Dn, Dm)                  ( __neon_QdDnDm_acc( 0xf2a00900, (Qd), (Dn), (Dm)) )
#define vqdmlsl_s16(Qd, Dn, Dm)                  ( __neon_QdDnDm_acc( 0xf2900b00, (Qd), (Dn), (Dm)) )
#define vqdmlsl_s32(Qd, Dn, Dm)                  ( __neon_QdDnDm_acc( 0xf2a00b00, (Qd), (Dn), (Dm)) )

// VQDMLAL, VQDMLSL (by scalar)
#define vqdmlal_lane_s16(Qd, Dn, Dm, lane)       ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2900340 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )
#define vqdmlal_lane_s32(Qd, Dn, Dm, lane)       ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2a00340 | _NENC_5(lane), (Qd), (Dn), (Dm)) )
#define vqdmlsl_lane_s16(Qd, Dn, Dm, lane)       ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2900740 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )
#define vqdmlsl_lane_s32(Qd, Dn, Dm, lane)       ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2a00740 | _NENC_5(lane), (Qd), (Dn), (Dm)) )

// VQDMULH (by scalar)
#define vqdmulh_lane_s16(Dn, Dm, lane)           ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx( 0xf2900c40 | _NENC_5x3(lane), (Dn), (Dm)) )
#define vqdmulh_lane_s32(Dn, Dm, lane)           ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00c40 | _NENC_5(lane), (Dn), (Dm)) )
#define vqrdmulh_lane_s16(Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx( 0xf2900d40 | _NENC_5x3(lane), (Dn), (Dm)) )
#define vqrdmulh_lane_s32(Dn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00d40 | _NENC_5(lane), (Dn), (Dm)) )
#define vqdmulhq_lane_s16(Qn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx( 0xf3900c40 | _NENC_5x3(lane), (Qn), (Dm)) )
#define vqdmulhq_lane_s32(Qn, Dm, lane)          ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00c40 | _NENC_5(lane), (Qn), (Dm)) )
#define vqrdmulhq_lane_s16(Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx( 0xf3900d40 | _NENC_5x3(lane), (Qn), (Dm)) )
#define vqrdmulhq_lane_s32(Qn, Dm, lane)         ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00d40 | _NENC_5(lane), (Qn), (Dm)) )

// VQDMULH, VQRDMULH
#define vqdmulh_s16(Dn, Dm)                      ( __neon_DdDnDm( 0xf2100b00, (Dn), (Dm)) )
#define vqdmulh_s32(Dn, Dm)                      ( __neon_DdDnDm( 0xf2200b00, (Dn), (Dm)) )
#define vqrdmulh_s16(Dn, Dm)                     ( __neon_DdDnDm( 0xf3100b00, (Dn), (Dm)) )
#define vqrdmulh_s32(Dn, Dm)                     ( __neon_DdDnDm( 0xf3200b00, (Dn), (Dm)) )
#define vqdmulhq_s16(Qn, Qm)                     ( __neon_QdQnQm( 0xf2100b40, (Qn), (Qm)) )
#define vqdmulhq_s32(Qn, Qm)                     ( __neon_QdQnQm( 0xf2200b40, (Qn), (Qm)) )
#define vqrdmulhq_s16(Qn, Qm)                    ( __neon_QdQnQm( 0xf3100b40, (Qn), (Qm)) )
#define vqrdmulhq_s32(Qn, Qm)                    ( __neon_QdQnQm( 0xf3200b40, (Qn), (Qm)) )

// VQDMULL
#define vqdmull_s16(Dn, Dm)                      ( __neon_QdDnDm( 0xf2900d00, (Dn), (Dm)) )
#define vqdmull_s32(Dn, Dm)                      ( __neon_QdDnDm( 0xf2a00d00, (Dn), (Dm)) )

// VQDMULL (by scalar)
#define vqdmull_lane_s16(Dn, Dm, lane)           ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx( 0xf2900b40 | _NENC_5x3(lane), (Dn), (Dm)) )
#define vqdmull_lane_s32(Dn, Dm, lane)           ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx( 0xf2a00b40 | _NENC_5(lane), (Dn), (Dm)) )

// VQMOVN, VQMOVUN
#define vqmovn_s16(Qm)                           ( __neon_DdQm( 0xf3b20280, (Qm)) )
#define vqmovn_s32(Qm)                           ( __neon_DdQm( 0xf3b60280, (Qm)) )
#define vqmovn_s64(Qm)                           ( __neon_DdQm( 0xf3ba0280, (Qm)) )
#define vqmovn_u16(Qm)                           ( __neon_DdQm( 0xf3b202c0, (Qm)) )
#define vqmovn_u32(Qm)                           ( __neon_DdQm( 0xf3b602c0, (Qm)) )
#define vqmovn_u64(Qm)                           ( __neon_DdQm( 0xf3ba02c0, (Qm)) )
#define vqmovun_s16(Qm)                          ( __neon_DdQm( 0xf3b20240, (Qm)) )
#define vqmovun_s32(Qm)                          ( __neon_DdQm( 0xf3b60240, (Qm)) )
#define vqmovun_s64(Qm)                          ( __neon_DdQm( 0xf3ba0240, (Qm)) )

// VQSHL, VQSHLU (immediate)
#define vqshl_n_s16(Dm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf2900710 | _NENC_19_16(shift_amount), (Dm)) )
#define vqshl_n_s32(Dm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf2a00710 | _NENC_20_16(shift_amount), (Dm)) )
#define vqshl_n_s64(Dm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf2800790 | _NENC_21_16(shift_amount), (Dm)) )
#define vqshl_n_s8(Dm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf2880710 | _NENC_18_16(shift_amount), (Dm)) )
#define vqshl_n_u16(Dm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf3900710 | _NENC_19_16(shift_amount), (Dm)) )
#define vqshl_n_u32(Dm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf3a00710 | _NENC_20_16(shift_amount), (Dm)) )
#define vqshl_n_u64(Dm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf3800790 | _NENC_21_16(shift_amount), (Dm)) )
#define vqshl_n_u8(Dm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf3880710 | _NENC_18_16(shift_amount), (Dm)) )
#define vqshlu_n_s16(Dm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf3900610 | _NENC_19_16(shift_amount), (Dm)) )
#define vqshlu_n_s32(Dm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf3a00610 | _NENC_20_16(shift_amount), (Dm)) )
#define vqshlu_n_s64(Dm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf3800690 | _NENC_21_16(shift_amount), (Dm)) )
#define vqshlu_n_s8(Dm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf3880610 | _NENC_18_16(shift_amount), (Dm)) )
#define vqshlq_n_s16(Qm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf2900750 | _NENC_19_16(shift_amount), (Qm)) )
#define vqshlq_n_s32(Qm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf2a00750 | _NENC_20_16(shift_amount), (Qm)) )
#define vqshlq_n_s64(Qm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf28007d0 | _NENC_21_16(shift_amount), (Qm)) )
#define vqshlq_n_s8(Qm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf2880750 | _NENC_18_16(shift_amount), (Qm)) )
#define vqshlq_n_u16(Qm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf3900750 | _NENC_19_16(shift_amount), (Qm)) )
#define vqshlq_n_u32(Qm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf3a00750 | _NENC_20_16(shift_amount), (Qm)) )
#define vqshlq_n_u64(Qm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf38007d0 | _NENC_21_16(shift_amount), (Qm)) )
#define vqshlq_n_u8(Qm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf3880750 | _NENC_18_16(shift_amount), (Qm)) )
#define vqshluq_n_s16(Qm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf3900650 | _NENC_19_16(shift_amount), (Qm)) )
#define vqshluq_n_s32(Qm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf3a00650 | _NENC_20_16(shift_amount), (Qm)) )
#define vqshluq_n_s64(Qm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf38006d0 | _NENC_21_16(shift_amount), (Qm)) )
#define vqshluq_n_s8(Qm, shift_amount)           ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf3880650 | _NENC_18_16(shift_amount), (Qm)) )

// VQSHRN, VQSHRUN, VQRSHRN, VQRSHRUN (immediate)
#define vqrshrn_n_s16(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880950 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vqrshrn_n_s32(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900950 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vqrshrn_n_s64(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00950 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vqrshrn_n_u16(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf3880950 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vqrshrn_n_u32(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf3900950 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vqrshrn_n_u64(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf3a00950 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vqrshrun_n_s16(Qm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf3880850 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vqrshrun_n_s32(Qm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf3900850 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vqrshrun_n_s64(Qm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf3a00850 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vqshrn_n_s16(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880910 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vqshrn_n_s32(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900910 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vqshrn_n_s64(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00910 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vqshrn_n_u16(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf3880910 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vqshrn_n_u32(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf3900910 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vqshrn_n_u64(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf3a00910 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vqshrun_n_s16(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf3880810 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vqshrun_n_s32(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf3900810 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vqshrun_n_s64(Qm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf3a00810 | _NENC_20_16(32 - (shift_amount)), (Qm)) )

// VQSUB
#define vqsub_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100210, (Dn), (Dm)) )
#define vqsub_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200210, (Dn), (Dm)) )
#define vqsub_s64(Dn, Dm)                        ( __neon_DdDnDm( 0xf2300210, (Dn), (Dm)) )
#define vqsub_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000210, (Dn), (Dm)) )
#define vqsub_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf3100210, (Dn), (Dm)) )
#define vqsub_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200210, (Dn), (Dm)) )
#define vqsub_u64(Dn, Dm)                        ( __neon_DdDnDm( 0xf3300210, (Dn), (Dm)) )
#define vqsub_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000210, (Dn), (Dm)) )
#define vqsubq_s16(Qn, Qm)                       ( __neon_QdQnQm( 0xf2100250, (Qn), (Qm)) )
#define vqsubq_s32(Qn, Qm)                       ( __neon_QdQnQm( 0xf2200250, (Qn), (Qm)) )
#define vqsubq_s64(Qn, Qm)                       ( __neon_QdQnQm( 0xf2300250, (Qn), (Qm)) )
#define vqsubq_s8(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000250, (Qn), (Qm)) )
#define vqsubq_u16(Qn, Qm)                       ( __neon_QdQnQm( 0xf3100250, (Qn), (Qm)) )
#define vqsubq_u32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3200250, (Qn), (Qm)) )
#define vqsubq_u64(Qn, Qm)                       ( __neon_QdQnQm( 0xf3300250, (Qn), (Qm)) )
#define vqsubq_u8(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000250, (Qn), (Qm)) )

// VRECPE, VRSQRTE
#define vrecpe_f32(Dm)                           ( __neon_DdDm( 0xf3bb0500, (Dm)) )
#define vrecpe_u32(Dm)                           ( __neon_DdDm( 0xf3bb0400, (Dm)) )
#define vrsqrte_f32(Dm)                          ( __neon_DdDm( 0xf3bb0580, (Dm)) )
#define vrsqrte_u32(Dm)                          ( __neon_DdDm( 0xf3bb0480, (Dm)) )
#define vrecpeq_f32(Qm)                          ( __neon_QdQm( 0xf3bb0540, (Qm)) )
#define vrecpeq_u32(Qm)                          ( __neon_QdQm( 0xf3bb0440, (Qm)) )
#define vrsqrteq_f32(Qm)                         ( __neon_QdQm( 0xf3bb05c0, (Qm)) )
#define vrsqrteq_u32(Qm)                         ( __neon_QdQm( 0xf3bb04c0, (Qm)) )

// VRECPS
#define vrecps_f32(Dn, Dm)                       ( __neon_DdDnDm( 0xf2000f10, (Dn), (Dm)) )
#define vrecpsq_f32(Qn, Qm)                      ( __neon_QdQnQm( 0xf2000f50, (Qn), (Qm)) )

// VREV
#define vrev16_p8(Dm)                            ( __neon_DdDm( 0xf3b00100, (Dm)) )
#define vrev16_s8(Dm)                            ( __neon_DdDm( 0xf3b00100, (Dm)) )
#define vrev16_u8(Dm)                            ( __neon_DdDm( 0xf3b00100, (Dm)) )
#define vrev32_p16(Dm)                           ( __neon_DdDm( 0xf3b40080, (Dm)) )
#define vrev32_p8(Dm)                            ( __neon_DdDm( 0xf3b00080, (Dm)) )
#define vrev32_s16(Dm)                           ( __neon_DdDm( 0xf3b40080, (Dm)) )
#define vrev32_s8(Dm)                            ( __neon_DdDm( 0xf3b00080, (Dm)) )
#define vrev32_u16(Dm)                           ( __neon_DdDm( 0xf3b40080, (Dm)) )
#define vrev32_u8(Dm)                            ( __neon_DdDm( 0xf3b00080, (Dm)) )
#define vrev64_f32(Dm)                           ( __neon_DdDm( 0xf3b80000, (Dm)) )
#define vrev64_p16(Dm)                           ( __neon_DdDm( 0xf3b40000, (Dm)) )
#define vrev64_p8(Dm)                            ( __neon_DdDm( 0xf3b00000, (Dm)) )
#define vrev64_s16(Dm)                           ( __neon_DdDm( 0xf3b40000, (Dm)) )
#define vrev64_s32(Dm)                           ( __neon_DdDm( 0xf3b80000, (Dm)) )
#define vrev64_s8(Dm)                            ( __neon_DdDm( 0xf3b00000, (Dm)) )
#define vrev64_u16(Dm)                           ( __neon_DdDm( 0xf3b40000, (Dm)) )
#define vrev64_u32(Dm)                           ( __neon_DdDm( 0xf3b80000, (Dm)) )
#define vrev64_u8(Dm)                            ( __neon_DdDm( 0xf3b00000, (Dm)) )
#define vrev16q_p8(Qm)                           ( __neon_QdQm( 0xf3b00140, (Qm)) )
#define vrev16q_s8(Qm)                           ( __neon_QdQm( 0xf3b00140, (Qm)) )
#define vrev16q_u8(Qm)                           ( __neon_QdQm( 0xf3b00140, (Qm)) )
#define vrev32q_p16(Qm)                          ( __neon_QdQm( 0xf3b400c0, (Qm)) )
#define vrev32q_p8(Qm)                           ( __neon_QdQm( 0xf3b000c0, (Qm)) )
#define vrev32q_s16(Qm)                          ( __neon_QdQm( 0xf3b400c0, (Qm)) )
#define vrev32q_s8(Qm)                           ( __neon_QdQm( 0xf3b000c0, (Qm)) )
#define vrev32q_u16(Qm)                          ( __neon_QdQm( 0xf3b400c0, (Qm)) )
#define vrev32q_u8(Qm)                           ( __neon_QdQm( 0xf3b000c0, (Qm)) )
#define vrev64q_f32(Qm)                          ( __neon_QdQm( 0xf3b80040, (Qm)) )
#define vrev64q_p16(Qm)                          ( __neon_QdQm( 0xf3b40040, (Qm)) )
#define vrev64q_p8(Qm)                           ( __neon_QdQm( 0xf3b00040, (Qm)) )
#define vrev64q_s16(Qm)                          ( __neon_QdQm( 0xf3b40040, (Qm)) )
#define vrev64q_s32(Qm)                          ( __neon_QdQm( 0xf3b80040, (Qm)) )
#define vrev64q_s8(Qm)                           ( __neon_QdQm( 0xf3b00040, (Qm)) )
#define vrev64q_u16(Qm)                          ( __neon_QdQm( 0xf3b40040, (Qm)) )
#define vrev64q_u32(Qm)                          ( __neon_QdQm( 0xf3b80040, (Qm)) )
#define vrev64q_u8(Qm)                           ( __neon_QdQm( 0xf3b00040, (Qm)) )

// VRINT
#define vrnd_f32(Dm)                             ( __neon_DdDm( 0xf3ba0580, (Dm)) )
#define vrnda_f32(Dm)                            ( __neon_DdDm( 0xf3ba0500, (Dm)) )
#define vrndm_f32(Dm)                            ( __neon_DdDm( 0xf3ba0680, (Dm)) )
#define vrndn_f32(Dm)                            ( __neon_DdDm( 0xf3ba0400, (Dm)) )
#define vrndp_f32(Dm)                            ( __neon_DdDm( 0xf3ba0780, (Dm)) )
#define vrndx_f32(Dm)                            ( __neon_DdDm( 0xf3ba0480, (Dm)) )
#define vrndq_f32(Qm)                            ( __neon_QdQm( 0xf3ba05c0, (Qm)) )
#define vrndaq_f32(Qm)                           ( __neon_QdQm( 0xf3ba0540, (Qm)) )
#define vrndmq_f32(Qm)                           ( __neon_QdQm( 0xf3ba06c0, (Qm)) )
#define vrndnq_f32(Qm)                           ( __neon_QdQm( 0xf3ba0440, (Qm)) )
#define vrndpq_f32(Qm)                           ( __neon_QdQm( 0xf3ba07c0, (Qm)) )
#define vrndxq_f32(Qm)                           ( __neon_QdQm( 0xf3ba04c0, (Qm)) )

// VRSQRTS
#define vrsqrts_f32(Dn, Dm)                      ( __neon_DdDnDm( 0xf2200f10, (Dn), (Dm)) )
#define vrsqrtsq_f32(Qn, Qm)                     ( __neon_QdQnQm( 0xf2200f50, (Qn), (Qm)) )

// VSHL (immediate)
#define vshl_n_s16(Dm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf2900510 | _NENC_19_16(shift_amount), (Dm)) )
#define vshl_n_s32(Dm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf2a00510 | _NENC_20_16(shift_amount), (Dm)) )
#define vshl_n_s64(Dm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf2800590 | _NENC_21_16(shift_amount), (Dm)) )
#define vshl_n_s8(Dm, shift_amount)              ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf2880510 | _NENC_18_16(shift_amount), (Dm)) )
#define vshl_n_u16(Dm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf2900510 | _NENC_19_16(shift_amount), (Dm)) )
#define vshl_n_u32(Dm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf2a00510 | _NENC_20_16(shift_amount), (Dm)) )
#define vshl_n_u64(Dm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf2800590 | _NENC_21_16(shift_amount), (Dm)) )
#define vshl_n_u8(Dm, shift_amount)              ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf2880510 | _NENC_18_16(shift_amount), (Dm)) )
#define vshlq_n_s16(Qm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf2900550 | _NENC_19_16(shift_amount), (Qm)) )
#define vshlq_n_s32(Qm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf2a00550 | _NENC_20_16(shift_amount), (Qm)) )
#define vshlq_n_s64(Qm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf28005d0 | _NENC_21_16(shift_amount), (Qm)) )
#define vshlq_n_s8(Qm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf2880550 | _NENC_18_16(shift_amount), (Qm)) )
#define vshlq_n_u16(Qm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf2900550 | _NENC_19_16(shift_amount), (Qm)) )
#define vshlq_n_u32(Qm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf2a00550 | _NENC_20_16(shift_amount), (Qm)) )
#define vshlq_n_u64(Qm, shift_amount)            ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf28005d0 | _NENC_21_16(shift_amount), (Qm)) )
#define vshlq_n_u8(Qm, shift_amount)             ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf2880550 | _NENC_18_16(shift_amount), (Qm)) )

// VSHL, VQSHL, VRSHL, VQRSHL (register)
#define vqrshl_s16(Dn, Dm)                       ( __neon_DdDnDm( 0xf2100510, (Dm), (Dn)) )
#define vqrshl_s32(Dn, Dm)                       ( __neon_DdDnDm( 0xf2200510, (Dm), (Dn)) )
#define vqrshl_s64(Dn, Dm)                       ( __neon_DdDnDm( 0xf2300510, (Dm), (Dn)) )
#define vqrshl_s8(Dn, Dm)                        ( __neon_DdDnDm( 0xf2000510, (Dm), (Dn)) )
#define vqrshl_u16(Dn, Dm)                       ( __neon_DdDnDm( 0xf3100510, (Dm), (Dn)) )
#define vqrshl_u32(Dn, Dm)                       ( __neon_DdDnDm( 0xf3200510, (Dm), (Dn)) )
#define vqrshl_u64(Dn, Dm)                       ( __neon_DdDnDm( 0xf3300510, (Dm), (Dn)) )
#define vqrshl_u8(Dn, Dm)                        ( __neon_DdDnDm( 0xf3000510, (Dm), (Dn)) )
#define vqshl_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100410, (Dm), (Dn)) )
#define vqshl_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200410, (Dm), (Dn)) )
#define vqshl_s64(Dn, Dm)                        ( __neon_DdDnDm( 0xf2300410, (Dm), (Dn)) )
#define vqshl_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000410, (Dm), (Dn)) )
#define vqshl_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf3100410, (Dm), (Dn)) )
#define vqshl_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200410, (Dm), (Dn)) )
#define vqshl_u64(Dn, Dm)                        ( __neon_DdDnDm( 0xf3300410, (Dm), (Dn)) )
#define vqshl_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000410, (Dm), (Dn)) )
#define vrshl_s16(Dn, Dm)                        ( __neon_DdDnDm( 0xf2100500, (Dm), (Dn)) )
#define vrshl_s32(Dn, Dm)                        ( __neon_DdDnDm( 0xf2200500, (Dm), (Dn)) )
#define vrshl_s64(Dn, Dm)                        ( __neon_DdDnDm( 0xf2300500, (Dm), (Dn)) )
#define vrshl_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf2000500, (Dm), (Dn)) )
#define vrshl_u16(Dn, Dm)                        ( __neon_DdDnDm( 0xf3100500, (Dm), (Dn)) )
#define vrshl_u32(Dn, Dm)                        ( __neon_DdDnDm( 0xf3200500, (Dm), (Dn)) )
#define vrshl_u64(Dn, Dm)                        ( __neon_DdDnDm( 0xf3300500, (Dm), (Dn)) )
#define vrshl_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3000500, (Dm), (Dn)) )
#define vshl_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100400, (Dm), (Dn)) )
#define vshl_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200400, (Dm), (Dn)) )
#define vshl_s64(Dn, Dm)                         ( __neon_DdDnDm( 0xf2300400, (Dm), (Dn)) )
#define vshl_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000400, (Dm), (Dn)) )
#define vshl_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100400, (Dm), (Dn)) )
#define vshl_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200400, (Dm), (Dn)) )
#define vshl_u64(Dn, Dm)                         ( __neon_DdDnDm( 0xf3300400, (Dm), (Dn)) )
#define vshl_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000400, (Dm), (Dn)) )
#define vqrshlq_s16(Qn, Qm)                      ( __neon_QdQnQm( 0xf2100550, (Qm), (Qn)) )
#define vqrshlq_s32(Qn, Qm)                      ( __neon_QdQnQm( 0xf2200550, (Qm), (Qn)) )
#define vqrshlq_s64(Qn, Qm)                      ( __neon_QdQnQm( 0xf2300550, (Qm), (Qn)) )
#define vqrshlq_s8(Qn, Qm)                       ( __neon_QdQnQm( 0xf2000550, (Qm), (Qn)) )
#define vqrshlq_u16(Qn, Qm)                      ( __neon_QdQnQm( 0xf3100550, (Qm), (Qn)) )
#define vqrshlq_u32(Qn, Qm)                      ( __neon_QdQnQm( 0xf3200550, (Qm), (Qn)) )
#define vqrshlq_u64(Qn, Qm)                      ( __neon_QdQnQm( 0xf3300550, (Qm), (Qn)) )
#define vqrshlq_u8(Qn, Qm)                       ( __neon_QdQnQm( 0xf3000550, (Qm), (Qn)) )
#define vqshlq_s16(Qn, Qm)                       ( __neon_QdQnQm( 0xf2100450, (Qm), (Qn)) )
#define vqshlq_s32(Qn, Qm)                       ( __neon_QdQnQm( 0xf2200450, (Qm), (Qn)) )
#define vqshlq_s64(Qn, Qm)                       ( __neon_QdQnQm( 0xf2300450, (Qm), (Qn)) )
#define vqshlq_s8(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000450, (Qm), (Qn)) )
#define vqshlq_u16(Qn, Qm)                       ( __neon_QdQnQm( 0xf3100450, (Qm), (Qn)) )
#define vqshlq_u32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3200450, (Qm), (Qn)) )
#define vqshlq_u64(Qn, Qm)                       ( __neon_QdQnQm( 0xf3300450, (Qm), (Qn)) )
#define vqshlq_u8(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000450, (Qm), (Qn)) )
#define vrshlq_s16(Qn, Qm)                       ( __neon_QdQnQm( 0xf2100540, (Qm), (Qn)) )
#define vrshlq_s32(Qn, Qm)                       ( __neon_QdQnQm( 0xf2200540, (Qm), (Qn)) )
#define vrshlq_s64(Qn, Qm)                       ( __neon_QdQnQm( 0xf2300540, (Qm), (Qn)) )
#define vrshlq_s8(Qn, Qm)                        ( __neon_QdQnQm( 0xf2000540, (Qm), (Qn)) )
#define vrshlq_u16(Qn, Qm)                       ( __neon_QdQnQm( 0xf3100540, (Qm), (Qn)) )
#define vrshlq_u32(Qn, Qm)                       ( __neon_QdQnQm( 0xf3200540, (Qm), (Qn)) )
#define vrshlq_u64(Qn, Qm)                       ( __neon_QdQnQm( 0xf3300540, (Qm), (Qn)) )
#define vrshlq_u8(Qn, Qm)                        ( __neon_QdQnQm( 0xf3000540, (Qm), (Qn)) )
#define vshlq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100440, (Qm), (Qn)) )
#define vshlq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200440, (Qm), (Qn)) )
#define vshlq_s64(Qn, Qm)                        ( __neon_QdQnQm( 0xf2300440, (Qm), (Qn)) )
#define vshlq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000440, (Qm), (Qn)) )
#define vshlq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100440, (Qm), (Qn)) )
#define vshlq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200440, (Qm), (Qn)) )
#define vshlq_u64(Qn, Qm)                        ( __neon_QdQnQm( 0xf3300440, (Qm), (Qn)) )
#define vshlq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000440, (Qm), (Qn)) )

// VSHLL (shift_amount != size)
#define __internal_vshll_n_t1_s16(Dm, shift_amount)         ( __neon_QdDm( 0xf2900a10 | _NENC_19_16(shift_amount), (Dm)) )
#define __internal_vshll_n_t1_s32(Dm, shift_amount)         ( __neon_QdDm( 0xf2a00a10 | _NENC_20_16(shift_amount), (Dm)) )
#define __internal_vshll_n_t1_s8(Dm, shift_amount)          ( __neon_QdDm( 0xf2880a10 | _NENC_18_16(shift_amount), (Dm)) )
#define __internal_vshll_n_t1_u16(Dm, shift_amount)         ( __neon_QdDm( 0xf3900a10 | _NENC_19_16(shift_amount), (Dm)) )
#define __internal_vshll_n_t1_u32(Dm, shift_amount)         ( __neon_QdDm( 0xf3a00a10 | _NENC_20_16(shift_amount), (Dm)) )
#define __internal_vshll_n_t1_u8(Dm, shift_amount)          ( __neon_QdDm( 0xf3880a10 | _NENC_18_16(shift_amount), (Dm)) )

// VSHLL (shift_amount == size)
#define __internal_vshll_n_t2_s16(Dm)                       ( __neon_QdDm( 0xf3b60300, (Dm)) )
#define __internal_vshll_n_t2_s32(Dm)                       ( __neon_QdDm( 0xf3ba0300, (Dm)) )
#define __internal_vshll_n_t2_s8(Dm)                        ( __neon_QdDm( 0xf3b20300, (Dm)) )
#define __internal_vshll_n_t2_u16(Dm)                       ( __neon_QdDm( 0xf3b60300, (Dm)) )
#define __internal_vshll_n_t2_u32(Dm)                       ( __neon_QdDm( 0xf3ba0300, (Dm)) )
#define __internal_vshll_n_t2_u8(Dm)                        ( __neon_QdDm( 0xf3b20300, (Dm)) )

// VSHR, VRSHR (immediate)
#define vrshr_n_s16(Dm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm( 0xf2900210 | _NENC_19_16(16 - (shift_amount)), (Dm)) )
#define vrshr_n_s32(Dm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm( 0xf2a00210 | _NENC_20_16(32 - (shift_amount)), (Dm)) )
#define vrshr_n_s64(Dm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm( 0xf2800290 | _NENC_21_16(64 - (shift_amount)), (Dm)) )
#define vrshr_n_s8(Dm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm( 0xf2880210 | _NENC_18_16(8 - (shift_amount)), (Dm)) )
#define vrshr_n_u16(Dm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm( 0xf3900210 | _NENC_19_16(16 - (shift_amount)), (Dm)) )
#define vrshr_n_u32(Dm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm( 0xf3a00210 | _NENC_20_16(32 - (shift_amount)), (Dm)) )
#define vrshr_n_u64(Dm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm( 0xf3800290 | _NENC_21_16(64 - (shift_amount)), (Dm)) )
#define vrshr_n_u8(Dm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm( 0xf3880210 | _NENC_18_16(8 - (shift_amount)), (Dm)) )
#define vshr_n_s16(Dm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm( 0xf2900010 | _NENC_19_16(16 - (shift_amount)), (Dm)) )
#define vshr_n_s32(Dm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm( 0xf2a00010 | _NENC_20_16(32 - (shift_amount)), (Dm)) )
#define vshr_n_s64(Dm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm( 0xf2800090 | _NENC_21_16(64 - (shift_amount)), (Dm)) )
#define vshr_n_s8(Dm, shift_amount)              ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm( 0xf2880010 | _NENC_18_16(8 - (shift_amount)), (Dm)) )
#define vshr_n_u16(Dm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm( 0xf3900010 | _NENC_19_16(16 - (shift_amount)), (Dm)) )
#define vshr_n_u32(Dm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm( 0xf3a00010 | _NENC_20_16(32 - (shift_amount)), (Dm)) )
#define vshr_n_u64(Dm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm( 0xf3800090 | _NENC_21_16(64 - (shift_amount)), (Dm)) )
#define vshr_n_u8(Dm, shift_amount)              ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm( 0xf3880010 | _NENC_18_16(8 - (shift_amount)), (Dm)) )
#define vrshrq_n_s16(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm( 0xf2900250 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vrshrq_n_s32(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm( 0xf2a00250 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vrshrq_n_s64(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm( 0xf28002d0 | _NENC_21_16(64 - (shift_amount)), (Qm)) )
#define vrshrq_n_s8(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm( 0xf2880250 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vrshrq_n_u16(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm( 0xf3900250 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vrshrq_n_u32(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm( 0xf3a00250 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vrshrq_n_u64(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm( 0xf38002d0 | _NENC_21_16(64 - (shift_amount)), (Qm)) )
#define vrshrq_n_u8(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm( 0xf3880250 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vshrq_n_s16(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm( 0xf2900050 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vshrq_n_s32(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm( 0xf2a00050 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vshrq_n_s64(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm( 0xf28000d0 | _NENC_21_16(64 - (shift_amount)), (Qm)) )
#define vshrq_n_s8(Qm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm( 0xf2880050 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vshrq_n_u16(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm( 0xf3900050 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vshrq_n_u32(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm( 0xf3a00050 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vshrq_n_u64(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm( 0xf38000d0 | _NENC_21_16(64 - (shift_amount)), (Qm)) )
#define vshrq_n_u8(Qm, shift_amount)             ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm( 0xf3880050 | _NENC_18_16(8 - (shift_amount)), (Qm)) )

// VSHRN, VRSHRN (immediate)
#define vrshrn_n_s16(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880850 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vrshrn_n_s32(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900850 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vrshrn_n_s64(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00850 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vrshrn_n_u16(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880850 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vrshrn_n_u32(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900850 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vrshrn_n_u64(Qm, shift_amount)           ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00850 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vshrn_n_s16(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880810 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vshrn_n_s32(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900810 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vshrn_n_s64(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00810 | _NENC_20_16(32 - (shift_amount)), (Qm)) )
#define vshrn_n_u16(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880810 | _NENC_18_16(8 - (shift_amount)), (Qm)) )
#define vshrn_n_u32(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900810 | _NENC_19_16(16 - (shift_amount)), (Qm)) )
#define vshrn_n_u64(Qm, shift_amount)            ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00810 | _NENC_20_16(32 - (shift_amount)), (Qm)) )

// VSLI (immediate)
#define vsli_n_p16(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900510 | _NENC_19_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_p8(Dd, Dm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880510 | _NENC_18_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_s16(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900510 | _NENC_19_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_s32(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00510 | _NENC_20_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_s64(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800590 | _NENC_21_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_s8(Dd, Dm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880510 | _NENC_18_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_u16(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900510 | _NENC_19_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_u32(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00510 | _NENC_20_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_u64(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800590 | _NENC_21_16(shift_amount), (Dd), (Dm)) )
#define vsli_n_u8(Dd, Dm, shift_amount)          ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880510 | _NENC_18_16(shift_amount), (Dd), (Dm)) )
#define vsliq_n_p16(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900550 | _NENC_19_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_p8(Qd, Qm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880550 | _NENC_18_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_s16(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900550 | _NENC_19_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_s32(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00550 | _NENC_20_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_s64(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38005d0 | _NENC_21_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_s8(Qd, Qm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880550 | _NENC_18_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_u16(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900550 | _NENC_19_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_u32(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00550 | _NENC_20_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_u64(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38005d0 | _NENC_21_16(shift_amount), (Qd), (Qm)) )
#define vsliq_n_u8(Qd, Qm, shift_amount)         ( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880550 | _NENC_18_16(shift_amount), (Qd), (Qm)) )

// VSRA, VRSRA (immediate)
#define vrsra_n_s16(Dd, Dm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf2900310 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )
#define vrsra_n_s32(Dd, Dm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf2a00310 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )
#define vrsra_n_s64(Dd, Dm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf2800390 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )
#define vrsra_n_s8(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf2880310 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )
#define vrsra_n_u16(Dd, Dm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900310 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )
#define vrsra_n_u32(Dd, Dm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00310 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )
#define vrsra_n_u64(Dd, Dm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800390 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )
#define vrsra_n_u8(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880310 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )
#define vsra_n_s16(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf2900110 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )
#define vsra_n_s32(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf2a00110 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )
#define vsra_n_s64(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf2800190 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )
#define vsra_n_s8(Dd, Dm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf2880110 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )
#define vsra_n_u16(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900110 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )
#define vsra_n_u32(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00110 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )
#define vsra_n_u64(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800190 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )
#define vsra_n_u8(Dd, Dm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880110 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )
#define vrsraq_n_s16(Qd, Qm, shift_amount)       ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf2900350 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )
#define vrsraq_n_s32(Qd, Qm, shift_amount)       ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf2a00350 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )
#define vrsraq_n_s64(Qd, Qm, shift_amount)       ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf28003d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )
#define vrsraq_n_s8(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf2880350 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )
#define vrsraq_n_u16(Qd, Qm, shift_amount)       ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900350 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )
#define vrsraq_n_u32(Qd, Qm, shift_amount)       ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00350 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )
#define vrsraq_n_u64(Qd, Qm, shift_amount)       ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38003d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )
#define vrsraq_n_u8(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880350 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )
#define vsraq_n_s16(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf2900150 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )
#define vsraq_n_s32(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf2a00150 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )
#define vsraq_n_s64(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf28001d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )
#define vsraq_n_s8(Qd, Qm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf2880150 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )
#define vsraq_n_u16(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900150 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )
#define vsraq_n_u32(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00150 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )
#define vsraq_n_u64(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38001d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )
#define vsraq_n_u8(Qd, Qm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880150 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )

// VSRI (immediate)
#define vsri_n_p16(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900410 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_p8(Dd, Dm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880410 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_s16(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900410 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_s32(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00410 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_s64(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800490 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_s8(Dd, Dm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880410 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_u16(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900410 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_u32(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00410 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_u64(Dd, Dm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800490 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )
#define vsri_n_u8(Dd, Dm, shift_amount)          ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880410 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )
#define vsriq_n_p16(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900450 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_p8(Qd, Qm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880450 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_s16(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900450 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_s32(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00450 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_s64(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38004d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_s8(Qd, Qm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880450 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_u16(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900450 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_u32(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00450 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_u64(Qd, Qm, shift_amount)        ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38004d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )
#define vsriq_n_u8(Qd, Qm, shift_amount)         ( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880450 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )

// VST1 (multiple single elements)
#define vst1_f32(pD, D)                          ( __neon_AdrD1( 0xf400078f, __float32ToN64(pD), (D)) )
#define vst1_p16(pD, D)                          ( __neon_AdrD1( 0xf400074f, __poly16ToN64(pD), (D)) )
#define vst1_p8(pD, D)                           ( __neon_AdrD1( 0xf400070f, __poly8ToN64(pD), (D)) )
#define vst1_s16(pD, D)                          ( __neon_AdrD1( 0xf400074f, __int16ToN64(pD), (D)) )
#define vst1_s32(pD, D)                          ( __neon_AdrD1( 0xf400078f, __int32ToN64(pD), (D)) )
#define vst1_s64(pD, D)                          ( __neon_AdrD1( 0xf40007cf, __int64ToN64(pD), (D)) )
#define vst1_s8(pD, D)                           ( __neon_AdrD1( 0xf400070f, __int8ToN64(pD), (D)) )
#define vst1_u16(pD, D)                          ( __neon_AdrD1( 0xf400074f, __uint16ToN64(pD), (D)) )
#define vst1_u32(pD, D)                          ( __neon_AdrD1( 0xf400078f, __uint32ToN64(pD), (D)) )
#define vst1_u64(pD, D)                          ( __neon_AdrD1( 0xf40007cf, __uint64ToN64(pD), (D)) )
#define vst1_u8(pD, D)                           ( __neon_AdrD1( 0xf400070f, __uint8ToN64(pD), (D)) )
#define vst1_f32_ex(pD, D, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400078f | _NENC_5_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (D)) )
#define vst1_p16_ex(pD, D, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400074f | _NENC_5_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (D)) )
#define vst1_p8_ex(pD, D, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400070f | _NENC_5_4(_NEON_ALIGN64(align)), __poly8ToN64(pD), (D)) )
#define vst1_s16_ex(pD, D, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400074f | _NENC_5_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (D)) )
#define vst1_s32_ex(pD, D, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400078f | _NENC_5_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (D)) )
#define vst1_s64_ex(pD, D, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf40007cf | _NENC_5_4(_NEON_ALIGN64(align)), __int64ToN64(pD), (D)) )
#define vst1_s8_ex(pD, D, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400070f | _NENC_5_4(_NEON_ALIGN64(align)), __int8ToN64(pD), (D)) )
#define vst1_u16_ex(pD, D, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400074f | _NENC_5_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (D)) )
#define vst1_u32_ex(pD, D, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400078f | _NENC_5_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (D)) )
#define vst1_u64_ex(pD, D, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf40007cf | _NENC_5_4(_NEON_ALIGN64(align)), __uint64ToN64(pD), (D)) )
#define vst1_u8_ex(pD, D, align)                 ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400070f | _NENC_5_4(_NEON_ALIGN64(align)), __uint8ToN64(pD), (D)) )
#define vst1q_f32(pD, Q)                         ( __neon_AdrQ1( 0xf4000a8f, __float32ToN64(pD), (Q)) )
#define vst1q_p16(pD, Q)                         ( __neon_AdrQ1( 0xf4000a4f, __poly16ToN64(pD), (Q)) )
#define vst1q_p8(pD, Q)                          ( __neon_AdrQ1( 0xf4000a0f, __poly8ToN64(pD), (Q)) )
#define vst1q_s16(pD, Q)                         ( __neon_AdrQ1( 0xf4000a4f, __int16ToN64(pD), (Q)) )
#define vst1q_s32(pD, Q)                         ( __neon_AdrQ1( 0xf4000a8f, __int32ToN64(pD), (Q)) )
#define vst1q_s64(pD, Q)                         ( __neon_AdrQ1( 0xf4000acf, __int64ToN64(pD), (Q)) )
#define vst1q_s8(pD, Q)                          ( __neon_AdrQ1( 0xf4000a0f, __int8ToN64(pD), (Q)) )
#define vst1q_u16(pD, Q)                         ( __neon_AdrQ1( 0xf4000a4f, __uint16ToN64(pD), (Q)) )
#define vst1q_u32(pD, Q)                         ( __neon_AdrQ1( 0xf4000a8f, __uint32ToN64(pD), (Q)) )
#define vst1q_u64(pD, Q)                         ( __neon_AdrQ1( 0xf4000acf, __uint64ToN64(pD), (Q)) )
#define vst1q_u8(pD, Q)                          ( __neon_AdrQ1( 0xf4000a0f, __uint8ToN64(pD), (Q)) )
#define vst1q_f32_ex(pD, Q, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (Q)) )
#define vst1q_p16_ex(pD, Q, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64(pD), (Q)) )
#define vst1q_p8_ex(pD, Q, align)                ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64(pD), (Q)) )
#define vst1q_s16_ex(pD, Q, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64(pD), (Q)) )
#define vst1q_s32_ex(pD, Q, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (Q)) )
#define vst1q_s64_ex(pD, Q, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64(pD), (Q)) )
#define vst1q_s8_ex(pD, Q, align)                ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64(pD), (Q)) )
#define vst1q_u16_ex(pD, Q, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64(pD), (Q)) )
#define vst1q_u32_ex(pD, Q, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (Q)) )
#define vst1q_u64_ex(pD, Q, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64(pD), (Q)) )
#define vst1q_u8_ex(pD, Q, align)                ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64(pD), (Q)) )

// VST1 (single element from one lane)
#define vst1_lane_f32(pD, D, lane)               ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrD1( 0xf480080f | _NENC_7(lane), __float32ToN64(pD), (D)) )
#define vst1_lane_p16(pD, D, lane)               ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane), __poly16ToN64(pD), (D)) )
#define vst1_lane_p8(pD, D, lane)                ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrD1( 0xf480000f | _NENC_7_5(lane), __poly8ToN64(pD), (D)) )
#define vst1_lane_s16(pD, D, lane)               ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane), __int16ToN64(pD), (D)) )
#define vst1_lane_s32(pD, D, lane)               ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrD1( 0xf480080f | _NENC_7(lane), __int32ToN64(pD), (D)) )
#define vst1_lane_s8(pD, D, lane)                ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrD1( 0xf480000f | _NENC_7_5(lane), __int8ToN64(pD), (D)) )
#define vst1_lane_u16(pD, D, lane)               ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane), __uint16ToN64(pD), (D)) )
#define vst1_lane_u32(pD, D, lane)               ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrD1( 0xf480080f | _NENC_7(lane), __uint32ToN64(pD), (D)) )
#define vst1_lane_u8(pD, D, lane)                ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrD1( 0xf480000f | _NENC_7_5(lane), __uint8ToN64(pD), (D)) )
#define vst1q_lane_f32(pD, Q, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __float32ToN64(pD), (Q)) )
#define vst1q_lane_p16(pD, Q, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __poly16ToN64(pD), (Q)) )
#define vst1q_lane_p8(pD, Q, lane)               ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_AdrQ1( 0xf480000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), __poly8ToN64(pD), (Q)) )
#define vst1q_lane_s16(pD, Q, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __int16ToN64(pD), (Q)) )
#define vst1q_lane_s32(pD, Q, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __int32ToN64(pD), (Q)) )
#define vst1q_lane_s8(pD, Q, lane)               ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_AdrQ1( 0xf480000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), __int8ToN64(pD), (Q)) )
#define vst1q_lane_u16(pD, Q, lane)              ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __uint16ToN64(pD), (Q)) )
#define vst1q_lane_u32(pD, Q, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __uint32ToN64(pD), (Q)) )
#define vst1q_lane_u8(pD, Q, lane)               ( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_AdrQ1( 0xf480000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), __uint8ToN64(pD), (Q)) )

// VST1 (single element from one lane, aligned)
#define vst1_lane_f32_ex(pD, D, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __float32ToN64(pD), (D)) )
#define vst1_lane_p16_ex(pD, D, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), __poly16ToN64(pD), (D)) )
#define vst1_lane_s16_ex(pD, D, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), __int16ToN64(pD), (D)) )
#define vst1_lane_s32_ex(pD, D, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __int32ToN64(pD), (D)) )
#define vst1_lane_u16_ex(pD, D, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), __uint16ToN64(pD), (D)) )
#define vst1_lane_u32_ex(pD, D, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __uint32ToN64(pD), (D)) )
#define vst1q_lane_f32_ex(pD, Q, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __float32ToN64(pD), (Q)) )
#define vst1q_lane_p16_ex(pD, Q, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), __poly16ToN64(pD), (Q)) )
#define vst1q_lane_s16_ex(pD, Q, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), __int16ToN64(pD), (Q)) )
#define vst1q_lane_s32_ex(pD, Q, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __int32ToN64(pD), (Q)) )
#define vst1q_lane_u16_ex(pD, Q, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), __uint16ToN64(pD), (Q)) )
#define vst1q_lane_u32_ex(pD, Q, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __uint32ToN64(pD), (Q)) )

// VST2 (multiple 2-element structures)
#define vst2_f32(pD, D2)                         ( __neon_AdrDx2( 0xf400088f, __float32ToN64(pD), (D2)) )
#define vst2_p16(pD, D2)                         ( __neon_AdrDx2( 0xf400084f, __poly16ToN64(pD), (D2)) )
#define vst2_p8(pD, D2)                          ( __neon_AdrDx2( 0xf400080f, __poly8ToN64(pD), (D2)) )
#define vst2_s16(pD, D2)                         ( __neon_AdrDx2( 0xf400084f, __int16ToN64(pD), (D2)) )
#define vst2_s32(pD, D2)                         ( __neon_AdrDx2( 0xf400088f, __int32ToN64(pD), (D2)) )
#define vst2_s8(pD, D2)                          ( __neon_AdrDx2( 0xf400080f, __int8ToN64(pD), (D2)) )
#define vst2_u16(pD, D2)                         ( __neon_AdrDx2( 0xf400084f, __uint16ToN64(pD), (D2)) )
#define vst2_u32(pD, D2)                         ( __neon_AdrDx2( 0xf400088f, __uint32ToN64(pD), (D2)) )
#define vst2_u8(pD, D2)                          ( __neon_AdrDx2( 0xf400080f, __uint8ToN64(pD), (D2)) )
#define vst2_s64(pD, D2)                         ( __neon_AdrDx2( 0xf4000acf, __int64ToN64(pD), (D2)) )
#define vst2_u64(pD, D2)                         ( __neon_AdrDx2( 0xf4000acf, __uint64ToN64(pD), (D2)) )
#define vst2_s64_ex(pD, D2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf4000acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64(pD), (D2)) )
#define vst2_u64_ex(pD, D2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf4000acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64(pD), (D2)) )
#define vst2_f32_ex(pD, D2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (D2)) )
#define vst2_p16_ex(pD, D2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64(pD), (D2)) )
#define vst2_p8_ex(pD, D2, align)                ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64(pD), (D2)) )
#define vst2_s16_ex(pD, D2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64(pD), (D2)) )
#define vst2_s32_ex(pD, D2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (D2)) )
#define vst2_s8_ex(pD, D2, align)                ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64(pD), (D2)) )
#define vst2_u16_ex(pD, D2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64(pD), (D2)) )
#define vst2_u32_ex(pD, D2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (D2)) )
#define vst2_u8_ex(pD, D2, align)                ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64(pD), (D2)) )
#define vst2q_f32(pD, Q2)                        ( __neon_AdrQx2( 0xf400098f, __float32ToN64(pD), (Q2)) )
#define vst2q_p16(pD, Q2)                        ( __neon_AdrQx2( 0xf400094f, __poly16ToN64(pD), (Q2)) )
#define vst2q_p8(pD, Q2)                         ( __neon_AdrQx2( 0xf400090f, __poly8ToN64(pD), (Q2)) )
#define vst2q_s16(pD, Q2)                        ( __neon_AdrQx2( 0xf400094f, __int16ToN64(pD), (Q2)) )
#define vst2q_s32(pD, Q2)                        ( __neon_AdrQx2( 0xf400098f, __int32ToN64(pD), (Q2)) )
#define vst2q_s8(pD, Q2)                         ( __neon_AdrQx2( 0xf400090f, __int8ToN64(pD), (Q2)) )
#define vst2q_u16(pD, Q2)                        ( __neon_AdrQx2( 0xf400094f, __uint16ToN64(pD), (Q2)) )
#define vst2q_u32(pD, Q2)                        ( __neon_AdrQx2( 0xf400098f, __uint32ToN64(pD), (Q2)) )
#define vst2q_u8(pD, Q2)                         ( __neon_AdrQx2( 0xf400090f, __uint8ToN64(pD), (Q2)) )
#define vst2q_f32_ex(pD, Q2, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (Q2)) )
#define vst2q_p16_ex(pD, Q2, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64(pD), (Q2)) )
#define vst2q_p8_ex(pD, Q2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64(pD), (Q2)) )
#define vst2q_s16_ex(pD, Q2, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64(pD), (Q2)) )
#define vst2q_s32_ex(pD, Q2, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (Q2)) )
#define vst2q_s8_ex(pD, Q2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64(pD), (Q2)) )
#define vst2q_u16_ex(pD, Q2, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64(pD), (Q2)) )
#define vst2q_u32_ex(pD, Q2, align)              ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (Q2)) )
#define vst2q_u8_ex(pD, Q2, align)               ( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64(pD), (Q2)) )

// VST2 (single 2-element structure from one lane)
#define vst2_lane_f32(pD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane), __float32ToN64(pD), (D2)) )
#define vst2_lane_p16(pD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane), __poly16ToN64(pD), (D2)) )
#define vst2_lane_p8(pD, D2, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane), __poly8ToN64(pD), (D2)) )
#define vst2_lane_s16(pD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane), __int16ToN64(pD), (D2)) )
#define vst2_lane_s32(pD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane), __int32ToN64(pD), (D2)) )
#define vst2_lane_s8(pD, D2, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane), __int8ToN64(pD), (D2)) )
#define vst2_lane_u16(pD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane), __uint16ToN64(pD), (D2)) )
#define vst2_lane_u32(pD, D2, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane), __uint32ToN64(pD), (D2)) )
#define vst2_lane_u8(pD, D2, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane), __uint8ToN64(pD), (D2)) )
#define vst2q_lane_f32(pD, Q2, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __float32ToN64(pD), (Q2)) )
#define vst2q_lane_p16(pD, Q2, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __poly16ToN64(pD), (Q2)) )
#define vst2q_lane_s16(pD, Q2, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __int16ToN64(pD), (Q2)) )
#define vst2q_lane_s32(pD, Q2, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __int32ToN64(pD), (Q2)) )
#define vst2q_lane_u16(pD, Q2, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __uint16ToN64(pD), (Q2)) )
#define vst2q_lane_u32(pD, Q2, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __uint32ToN64(pD), (Q2)) )

// VST2 (single 2-element structure from one lane, aligned)
#define vst2_lane_f32_ex(pD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (D2)) )
#define vst2_lane_p16_ex(pD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), __poly16ToN64(pD), (D2)) )
#define vst2_lane_p8_ex(pD, D2, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), __poly8ToN64(pD), (D2)) )
#define vst2_lane_s16_ex(pD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), __int16ToN64(pD), (D2)) )
#define vst2_lane_s32_ex(pD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (D2)) )
#define vst2_lane_s8_ex(pD, D2, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), __int8ToN64(pD), (D2)) )
#define vst2_lane_u16_ex(pD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), __uint16ToN64(pD), (D2)) )
#define vst2_lane_u32_ex(pD, D2, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (D2)) )
#define vst2_lane_u8_ex(pD, D2, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), __uint8ToN64(pD), (D2)) )
#define vst2q_lane_f32_ex(pD, Q2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (Q2)) )
#define vst2q_lane_p16_ex(pD, Q2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), __poly16ToN64(pD), (Q2)) )
#define vst2q_lane_s16_ex(pD, Q2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), __int16ToN64(pD), (Q2)) )
#define vst2q_lane_s32_ex(pD, Q2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (Q2)) )
#define vst2q_lane_u16_ex(pD, Q2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), __uint16ToN64(pD), (Q2)) )
#define vst2q_lane_u32_ex(pD, Q2, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (Q2)) )

// VST3 (multiple 3-element structures)
#define vst3_f32(pD, D3)                         ( __neon_AdrDx3( 0xf400048f, __float32ToN64(pD), (D3)) )
#define vst3_p16(pD, D3)                         ( __neon_AdrDx3( 0xf400044f, __poly16ToN64(pD), (D3)) )
#define vst3_p8(pD, D3)                          ( __neon_AdrDx3( 0xf400040f, __poly8ToN64(pD), (D3)) )
#define vst3_s16(pD, D3)                         ( __neon_AdrDx3( 0xf400044f, __int16ToN64(pD), (D3)) )
#define vst3_s32(pD, D3)                         ( __neon_AdrDx3( 0xf400048f, __int32ToN64(pD), (D3)) )
#define vst3_s8(pD, D3)                          ( __neon_AdrDx3( 0xf400040f, __int8ToN64(pD), (D3)) )
#define vst3_u16(pD, D3)                         ( __neon_AdrDx3( 0xf400044f, __uint16ToN64(pD), (D3)) )
#define vst3_u32(pD, D3)                         ( __neon_AdrDx3( 0xf400048f, __uint32ToN64(pD), (D3)) )
#define vst3_u8(pD, D3)                          ( __neon_AdrDx3( 0xf400040f, __uint8ToN64(pD), (D3)) )
#define vst3_s64(pD, D3)                         ( __neon_AdrDx3( 0xf40006cf, __int64ToN64(pD), (D3)) )
#define vst3_u64(pD, D3)                         ( __neon_AdrDx3( 0xf40006cf, __uint64ToN64(pD), (D3)) )
#define vst3_s64_ex(pD, D3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf40006cf | _NENC_4(_NEON_ALIGN64(align)), __int64ToN64(pD), (D3)) )
#define vst3_u64_ex(pD, D3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf40006cf | _NENC_4(_NEON_ALIGN64(align)), __uint64ToN64(pD), (D3)) )
#define vst3_f32_ex(pD, D3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400048f | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (D3)) )
#define vst3_p16_ex(pD, D3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400044f | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (D3)) )
#define vst3_p8_ex(pD, D3, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400040f | _NENC_4(_NEON_ALIGN64(align)), __poly8ToN64(pD), (D3)) )
#define vst3_s16_ex(pD, D3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400044f | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (D3)) )
#define vst3_s32_ex(pD, D3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400048f | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (D3)) )
#define vst3_s8_ex(pD, D3, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400040f | _NENC_4(_NEON_ALIGN64(align)), __int8ToN64(pD), (D3)) )
#define vst3_u16_ex(pD, D3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400044f | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (D3)) )
#define vst3_u32_ex(pD, D3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400048f | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (D3)) )
#define vst3_u8_ex(pD, D3, align)                ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400040f | _NENC_4(_NEON_ALIGN64(align)), __uint8ToN64(pD), (D3)) )
#define vst3q_f32(pD, Q3)                        ( __neon_AdrQx3( 0xf400058f, __float32ToN64(pD), (Q3)) )
#define vst3q_p16(pD, Q3)                        ( __neon_AdrQx3( 0xf400054f, __poly16ToN64(pD), (Q3)) )
#define vst3q_p8(pD, Q3)                         ( __neon_AdrQx3( 0xf400050f, __poly8ToN64(pD), (Q3)) )
#define vst3q_s16(pD, Q3)                        ( __neon_AdrQx3( 0xf400054f, __int16ToN64(pD), (Q3)) )
#define vst3q_s32(pD, Q3)                        ( __neon_AdrQx3( 0xf400058f, __int32ToN64(pD), (Q3)) )
#define vst3q_s8(pD, Q3)                         ( __neon_AdrQx3( 0xf400050f, __int8ToN64(pD), (Q3)) )
#define vst3q_u16(pD, Q3)                        ( __neon_AdrQx3( 0xf400054f, __uint16ToN64(pD), (Q3)) )
#define vst3q_u32(pD, Q3)                        ( __neon_AdrQx3( 0xf400058f, __uint32ToN64(pD), (Q3)) )
#define vst3q_u8(pD, Q3)                         ( __neon_AdrQx3( 0xf400050f, __uint8ToN64(pD), (Q3)) )
#define vst3q_f32_ex(pD, Q3, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400058f | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (Q3)) )
#define vst3q_p16_ex(pD, Q3, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400054f | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (Q3)) )
#define vst3q_p8_ex(pD, Q3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400050f | _NENC_4(_NEON_ALIGN64(align)), __poly8ToN64(pD), (Q3)) )
#define vst3q_s16_ex(pD, Q3, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400054f | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (Q3)) )
#define vst3q_s32_ex(pD, Q3, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400058f | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (Q3)) )
#define vst3q_s8_ex(pD, Q3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400050f | _NENC_4(_NEON_ALIGN64(align)), __int8ToN64(pD), (Q3)) )
#define vst3q_u16_ex(pD, Q3, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400054f | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (Q3)) )
#define vst3q_u32_ex(pD, Q3, align)              ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400058f | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (Q3)) )
#define vst3q_u8_ex(pD, Q3, align)               ( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400050f | _NENC_4(_NEON_ALIGN64(align)), __uint8ToN64(pD), (Q3)) )

// VST3 (single 3-element structure from one lane)
#define vst3_lane_f32(pD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx3x( 0xf4800a0f | _NENC_7(lane), __float32ToN64(pD), (D3)) )
#define vst3_lane_p16(pD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx3x( 0xf480060f | _NENC_7_6(lane), __poly16ToN64(pD), (D3)) )
#define vst3_lane_p8(pD, D3, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx3x( 0xf480020f | _NENC_7_5(lane), __poly8ToN64(pD), (D3)) )
#define vst3_lane_s16(pD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx3x( 0xf480060f | _NENC_7_6(lane), __int16ToN64(pD), (D3)) )
#define vst3_lane_s32(pD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx3x( 0xf4800a0f | _NENC_7(lane), __int32ToN64(pD), (D3)) )
#define vst3_lane_s8(pD, D3, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx3x( 0xf480020f | _NENC_7_5(lane), __int8ToN64(pD), (D3)) )
#define vst3_lane_u16(pD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx3x( 0xf480060f | _NENC_7_6(lane), __uint16ToN64(pD), (D3)) )
#define vst3_lane_u32(pD, D3, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx3x( 0xf4800a0f | _NENC_7(lane), __uint32ToN64(pD), (D3)) )
#define vst3_lane_u8(pD, D3, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx3x( 0xf480020f | _NENC_7_5(lane), __uint8ToN64(pD), (D3)) )
#define vst3q_lane_f32(pD, Q3, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx3x( 0xf4800a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __float32ToN64(pD), (Q3)) )
#define vst3q_lane_p16(pD, Q3, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx3x( 0xf480062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __poly16ToN64(pD), (Q3)) )
#define vst3q_lane_s16(pD, Q3, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx3x( 0xf480062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __int16ToN64(pD), (Q3)) )
#define vst3q_lane_s32(pD, Q3, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx3x( 0xf4800a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __int32ToN64(pD), (Q3)) )
#define vst3q_lane_u16(pD, Q3, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx3x( 0xf480062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __uint16ToN64(pD), (Q3)) )
#define vst3q_lane_u32(pD, Q3, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx3x( 0xf4800a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __uint32ToN64(pD), (Q3)) )

// VST4 (multiple 4-element structures)
#define vst4_f32(pD, D4)                         ( __neon_AdrDx4( 0xf400008f, __float32ToN64(pD), (D4)) )
#define vst4_p16(pD, D4)                         ( __neon_AdrDx4( 0xf400004f, __poly16ToN64(pD), (D4)) )
#define vst4_p8(pD, D4)                          ( __neon_AdrDx4( 0xf400000f, __poly8ToN64(pD), (D4)) )
#define vst4_s16(pD, D4)                         ( __neon_AdrDx4( 0xf400004f, __int16ToN64(pD), (D4)) )
#define vst4_s32(pD, D4)                         ( __neon_AdrDx4( 0xf400008f, __int32ToN64(pD), (D4)) )
#define vst4_s8(pD, D4)                          ( __neon_AdrDx4( 0xf400000f, __int8ToN64(pD), (D4)) )
#define vst4_u16(pD, D4)                         ( __neon_AdrDx4( 0xf400004f, __uint16ToN64(pD), (D4)) )
#define vst4_u32(pD, D4)                         ( __neon_AdrDx4( 0xf400008f, __uint32ToN64(pD), (D4)) )
#define vst4_u8(pD, D4)                          ( __neon_AdrDx4( 0xf400000f, __uint8ToN64(pD), (D4)) )
#define vst4_s64(pD, D4)                         ( __neon_AdrDx4( 0xf40002cf, __int64ToN64(pD), (D4)) )
#define vst4_u64(pD, D4)                         ( __neon_AdrDx4( 0xf40002cf, __uint64ToN64(pD), (D4)) )
#define vst4_s64_ex(pD, D4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf40002cf | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int64ToN64(pD), (D4)) )
#define vst4_u64_ex(pD, D4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf40002cf | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint64ToN64(pD), (D4)) )
#define vst4_f32_ex(pD, D4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __float32ToN64(pD), (D4)) )
#define vst4_p16_ex(pD, D4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly16ToN64(pD), (D4)) )
#define vst4_p8_ex(pD, D4, align)                ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly8ToN64(pD), (D4)) )
#define vst4_s16_ex(pD, D4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int16ToN64(pD), (D4)) )
#define vst4_s32_ex(pD, D4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int32ToN64(pD), (D4)) )
#define vst4_s8_ex(pD, D4, align)                ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int8ToN64(pD), (D4)) )
#define vst4_u16_ex(pD, D4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint16ToN64(pD), (D4)) )
#define vst4_u32_ex(pD, D4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint32ToN64(pD), (D4)) )
#define vst4_u8_ex(pD, D4, align)                ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint8ToN64(pD), (D4)) )
#define vst4q_f32(pD, Q4)                        ( __neon_AdrQx4( 0xf400018f, __float32ToN64(pD), (Q4)) )
#define vst4q_p16(pD, Q4)                        ( __neon_AdrQx4( 0xf400014f, __poly16ToN64(pD), (Q4)) )
#define vst4q_p8(pD, Q4)                         ( __neon_AdrQx4( 0xf400010f, __poly8ToN64(pD), (Q4)) )
#define vst4q_s16(pD, Q4)                        ( __neon_AdrQx4( 0xf400014f, __int16ToN64(pD), (Q4)) )
#define vst4q_s32(pD, Q4)                        ( __neon_AdrQx4( 0xf400018f, __int32ToN64(pD), (Q4)) )
#define vst4q_s8(pD, Q4)                         ( __neon_AdrQx4( 0xf400010f, __int8ToN64(pD), (Q4)) )
#define vst4q_u16(pD, Q4)                        ( __neon_AdrQx4( 0xf400014f, __uint16ToN64(pD), (Q4)) )
#define vst4q_u32(pD, Q4)                        ( __neon_AdrQx4( 0xf400018f, __uint32ToN64(pD), (Q4)) )
#define vst4q_u8(pD, Q4)                         ( __neon_AdrQx4( 0xf400010f, __uint8ToN64(pD), (Q4)) )
#define vst4q_f32_ex(pD, Q4, align)              ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __float32ToN64(pD), (Q4)) )
#define vst4q_p16_ex(pD, Q4, align)              ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly16ToN64(pD), (Q4)) )
#define vst4q_p8_ex(pD, Q4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly8ToN64(pD), (Q4)) )
#define vst4q_s16_ex(pD, Q4, align)              ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int16ToN64(pD), (Q4)) )
#define vst4q_s32_ex(pD, Q4, align)              ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int32ToN64(pD), (Q4)) )
#define vst4q_s8_ex(pD, Q4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int8ToN64(pD), (Q4)) )
#define vst4q_u16_ex(pD, Q4, align)              ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint16ToN64(pD), (Q4)) )
#define vst4q_u32_ex(pD, Q4, align)              ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint32ToN64(pD), (Q4)) )
#define vst4q_u8_ex(pD, Q4, align)               ( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint8ToN64(pD), (Q4)) )

// VST4 (single 4-element structure from one lane)
#define vst4_lane_f32(pD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane), __float32ToN64(pD), (D4)) )
#define vst4_lane_p16(pD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane), __poly16ToN64(pD), (D4)) )
#define vst4_lane_p8(pD, D4, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane), __poly8ToN64(pD), (D4)) )
#define vst4_lane_s16(pD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane), __int16ToN64(pD), (D4)) )
#define vst4_lane_s32(pD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane), __int32ToN64(pD), (D4)) )
#define vst4_lane_s8(pD, D4, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane), __int8ToN64(pD), (D4)) )
#define vst4_lane_u16(pD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane), __uint16ToN64(pD), (D4)) )
#define vst4_lane_u32(pD, D4, lane)              ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane), __uint32ToN64(pD), (D4)) )
#define vst4_lane_u8(pD, D4, lane)               ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane), __uint8ToN64(pD), (D4)) )
#define vst4q_lane_f32(pD, Q4, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __float32ToN64(pD), (Q4)) )
#define vst4q_lane_p16(pD, Q4, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __poly16ToN64(pD), (Q4)) )
#define vst4q_lane_s16(pD, Q4, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __int16ToN64(pD), (Q4)) )
#define vst4q_lane_s32(pD, Q4, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __int32ToN64(pD), (Q4)) )
#define vst4q_lane_u16(pD, Q4, lane)             ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __uint16ToN64(pD), (Q4)) )
#define vst4q_lane_u32(pD, Q4, lane)             ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __uint32ToN64(pD), (Q4)) )

// VST4 (single 4-element structure from one lane, aligned)
#define vst4_lane_f32_ex(pD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (D4)) )
#define vst4_lane_p16_ex(pD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (D4)) )
#define vst4_lane_p8_ex(pD, D4, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), __poly8ToN64(pD), (D4)) )
#define vst4_lane_s16_ex(pD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (D4)) )
#define vst4_lane_s32_ex(pD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (D4)) )
#define vst4_lane_s8_ex(pD, D4, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), __int8ToN64(pD), (D4)) )
#define vst4_lane_u16_ex(pD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (D4)) )
#define vst4_lane_u32_ex(pD, D4, lane, align)    ( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (D4)) )
#define vst4_lane_u8_ex(pD, D4, lane, align)     ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), __uint8ToN64(pD), (D4)) )
#define vst4q_lane_f32_ex(pD, Q4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (Q4)) )
#define vst4q_lane_p16_ex(pD, Q4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (Q4)) )
#define vst4q_lane_s16_ex(pD, Q4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (Q4)) )
#define vst4q_lane_s32_ex(pD, Q4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (Q4)) )
#define vst4q_lane_u16_ex(pD, Q4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (Q4)) )
#define vst4q_lane_u32_ex(pD, Q4, lane, align)   ( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (Q4)) )

// VSUB
#define vsub_f32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200d00, (Dn), (Dm)) )
#define vsub_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100800, (Dn), (Dm)) )
#define vsub_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200800, (Dn), (Dm)) )
#define vsub_s64(Dn, Dm)                         ( __neon_DdDnDm( 0xf3300800, (Dn), (Dm)) )
#define vsub_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000800, (Dn), (Dm)) )
#define vsub_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf3100800, (Dn), (Dm)) )
#define vsub_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf3200800, (Dn), (Dm)) )
#define vsub_u64(Dn, Dm)                         ( __neon_DdDnDm( 0xf3300800, (Dn), (Dm)) )
#define vsub_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf3000800, (Dn), (Dm)) )
#define vsubq_f32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200d40, (Qn), (Qm)) )
#define vsubq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100840, (Qn), (Qm)) )
#define vsubq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200840, (Qn), (Qm)) )
#define vsubq_s64(Qn, Qm)                        ( __neon_QdQnQm( 0xf3300840, (Qn), (Qm)) )
#define vsubq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000840, (Qn), (Qm)) )
#define vsubq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf3100840, (Qn), (Qm)) )
#define vsubq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf3200840, (Qn), (Qm)) )
#define vsubq_u64(Qn, Qm)                        ( __neon_QdQnQm( 0xf3300840, (Qn), (Qm)) )
#define vsubq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf3000840, (Qn), (Qm)) )

// VSUBHN, VRSUBHN
#define vrsubhn_s16(Qn, Qm)                      ( __neon_DdQnQm( 0xf3800600, (Qn), (Qm)) )
#define vrsubhn_s32(Qn, Qm)                      ( __neon_DdQnQm( 0xf3900600, (Qn), (Qm)) )
#define vrsubhn_s64(Qn, Qm)                      ( __neon_DdQnQm( 0xf3a00600, (Qn), (Qm)) )
#define vrsubhn_u16(Qn, Qm)                      ( __neon_DdQnQm( 0xf3800600, (Qn), (Qm)) )
#define vrsubhn_u32(Qn, Qm)                      ( __neon_DdQnQm( 0xf3900600, (Qn), (Qm)) )
#define vrsubhn_u64(Qn, Qm)                      ( __neon_DdQnQm( 0xf3a00600, (Qn), (Qm)) )
#define vsubhn_s16(Qn, Qm)                       ( __neon_DdQnQm( 0xf2800600, (Qn), (Qm)) )
#define vsubhn_s32(Qn, Qm)                       ( __neon_DdQnQm( 0xf2900600, (Qn), (Qm)) )
#define vsubhn_s64(Qn, Qm)                       ( __neon_DdQnQm( 0xf2a00600, (Qn), (Qm)) )
#define vsubhn_u16(Qn, Qm)                       ( __neon_DdQnQm( 0xf2800600, (Qn), (Qm)) )
#define vsubhn_u32(Qn, Qm)                       ( __neon_DdQnQm( 0xf2900600, (Qn), (Qm)) )
#define vsubhn_u64(Qn, Qm)                       ( __neon_DdQnQm( 0xf2a00600, (Qn), (Qm)) )

// VSUBL, VSUBW
#define vsubl_s16(Dn, Dm)                        ( __neon_QdDnDm( 0xf2900200, (Dn), (Dm)) )
#define vsubl_s32(Dn, Dm)                        ( __neon_QdDnDm( 0xf2a00200, (Dn), (Dm)) )
#define vsubl_s8(Dn, Dm)                         ( __neon_QdDnDm( 0xf2800200, (Dn), (Dm)) )
#define vsubl_u16(Dn, Dm)                        ( __neon_QdDnDm( 0xf3900200, (Dn), (Dm)) )
#define vsubl_u32(Dn, Dm)                        ( __neon_QdDnDm( 0xf3a00200, (Dn), (Dm)) )
#define vsubl_u8(Dn, Dm)                         ( __neon_QdDnDm( 0xf3800200, (Dn), (Dm)) )
#define vsubw_s16(Qn, Dm)                        ( __neon_QdQnDm( 0xf2900300, (Qn), (Dm)) )
#define vsubw_s32(Qn, Dm)                        ( __neon_QdQnDm( 0xf2a00300, (Qn), (Dm)) )
#define vsubw_s8(Qn, Dm)                         ( __neon_QdQnDm( 0xf2800300, (Qn), (Dm)) )
#define vsubw_u16(Qn, Dm)                        ( __neon_QdQnDm( 0xf3900300, (Qn), (Dm)) )
#define vsubw_u32(Qn, Dm)                        ( __neon_QdQnDm( 0xf3a00300, (Qn), (Dm)) )
#define vsubw_u8(Qn, Dm)                         ( __neon_QdQnDm( 0xf3800300, (Qn), (Dm)) )

// VTBL, VTBX
#define vtbl2_p8(D2, Dm)                         ( __neon_DdDx2Dm( 0xf3b00900, (D2), (Dm)) )
#define vtbl2_s8(D2, Dm)                         ( __neon_DdDx2Dm( 0xf3b00900, (D2), (Dm)) )
#define vtbl2_u8(D2, Dm)                         ( __neon_DdDx2Dm( 0xf3b00900, (D2), (Dm)) )
#define vtbx2_p8(Dd, D2, Dm)                     ( __neon_DdDx2Dm_acc( 0xf3b00940, (Dd), (D2), (Dm)) )
#define vtbx2_s8(Dd, D2, Dm)                     ( __neon_DdDx2Dm_acc( 0xf3b00940, (Dd), (D2), (Dm)) )
#define vtbx2_u8(Dd, D2, Dm)                     ( __neon_DdDx2Dm_acc( 0xf3b00940, (Dd), (D2), (Dm)) )
#define vtbl3_p8(D3, Dm)                         ( __neon_DdDx3Dm( 0xf3b00a00, (D3), (Dm)) )
#define vtbl3_s8(D3, Dm)                         ( __neon_DdDx3Dm( 0xf3b00a00, (D3), (Dm)) )
#define vtbl3_u8(D3, Dm)                         ( __neon_DdDx3Dm( 0xf3b00a00, (D3), (Dm)) )
#define vtbx3_p8(Dd, D3, Dm)                     ( __neon_DdDx3Dm_acc( 0xf3b00a40, (Dd), (D3), (Dm)) )
#define vtbx3_s8(Dd, D3, Dm)                     ( __neon_DdDx3Dm_acc( 0xf3b00a40, (Dd), (D3), (Dm)) )
#define vtbx3_u8(Dd, D3, Dm)                     ( __neon_DdDx3Dm_acc( 0xf3b00a40, (Dd), (D3), (Dm)) )
#define vtbl4_p8(D4, Dm)                         ( __neon_DdDx4Dm( 0xf3b00b00, (D4), (Dm)) )
#define vtbl4_s8(D4, Dm)                         ( __neon_DdDx4Dm( 0xf3b00b00, (D4), (Dm)) )
#define vtbl4_u8(D4, Dm)                         ( __neon_DdDx4Dm( 0xf3b00b00, (D4), (Dm)) )
#define vtbx4_p8(Dd, D4, Dm)                     ( __neon_DdDx4Dm_acc( 0xf3b00b40, (Dd), (D4), (Dm)) )
#define vtbx4_s8(Dd, D4, Dm)                     ( __neon_DdDx4Dm_acc( 0xf3b00b40, (Dd), (D4), (Dm)) )
#define vtbx4_u8(Dd, D4, Dm)                     ( __neon_DdDx4Dm_acc( 0xf3b00b40, (Dd), (D4), (Dm)) )
#define vtbl1_p8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3b00800, (Dn), (Dm)) )
#define vtbl1_s8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3b00800, (Dn), (Dm)) )
#define vtbl1_u8(Dn, Dm)                         ( __neon_DdDnDm( 0xf3b00800, (Dn), (Dm)) )
#define vtbx1_p8(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3b00840, (Dd), (Dn), (Dm)) )
#define vtbx1_s8(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3b00840, (Dd), (Dn), (Dm)) )
#define vtbx1_u8(Dd, Dn, Dm)                     ( __neon_DdDnDm_acc( 0xf3b00840, (Dd), (Dn), (Dm)) )

// VTRN
#define vtrn_f32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vtrn_p16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60080, (Dd), (Dm)) )
#define vtrn_p8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20080, (Dd), (Dm)) )
#define vtrn_s16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60080, (Dd), (Dm)) )
#define vtrn_s32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vtrn_s8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20080, (Dd), (Dm)) )
#define vtrn_u16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60080, (Dd), (Dm)) )
#define vtrn_u32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vtrn_u8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20080, (Dd), (Dm)) )
#define vtrnq_f32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba00c0, (Qd), (Qm)) )
#define vtrnq_p16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b600c0, (Qd), (Qm)) )
#define vtrnq_p8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b200c0, (Qd), (Qm)) )
#define vtrnq_s16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b600c0, (Qd), (Qm)) )
#define vtrnq_s32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba00c0, (Qd), (Qm)) )
#define vtrnq_s8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b200c0, (Qd), (Qm)) )
#define vtrnq_u16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b600c0, (Qd), (Qm)) )
#define vtrnq_u32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba00c0, (Qd), (Qm)) )
#define vtrnq_u8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b200c0, (Qd), (Qm)) )

// VTRNQ64
#define vtrnq_s64(Qd, Qm)                        ( __neon_QdQm_acc3( 0x00000000, (Qd), (Qm)) )
#define vtrnq_u64(Qd, Qm)                        ( __neon_QdQm_acc3( 0x00000000, (Qd), (Qm)) )

// VTST
#define vtst_p8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000810, (Dn), (Dm)) )
#define vtst_s16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100810, (Dn), (Dm)) )
#define vtst_s32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200810, (Dn), (Dm)) )
#define vtst_s8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000810, (Dn), (Dm)) )
#define vtst_u16(Dn, Dm)                         ( __neon_DdDnDm( 0xf2100810, (Dn), (Dm)) )
#define vtst_u32(Dn, Dm)                         ( __neon_DdDnDm( 0xf2200810, (Dn), (Dm)) )
#define vtst_u8(Dn, Dm)                          ( __neon_DdDnDm( 0xf2000810, (Dn), (Dm)) )
#define vtstq_p8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000850, (Qn), (Qm)) )
#define vtstq_s16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100850, (Qn), (Qm)) )
#define vtstq_s32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200850, (Qn), (Qm)) )
#define vtstq_s8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000850, (Qn), (Qm)) )
#define vtstq_u16(Qn, Qm)                        ( __neon_QdQnQm( 0xf2100850, (Qn), (Qm)) )
#define vtstq_u32(Qn, Qm)                        ( __neon_QdQnQm( 0xf2200850, (Qn), (Qm)) )
#define vtstq_u8(Qn, Qm)                         ( __neon_QdQnQm( 0xf2000850, (Qn), (Qm)) )

// VUZP
#define vuzp_p16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60100, (Dd), (Dm)) )
#define vuzp_p8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20100, (Dd), (Dm)) )
#define vuzp_s16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60100, (Dd), (Dm)) )
#define vuzp_s8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20100, (Dd), (Dm)) )
#define vuzp_u16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60100, (Dd), (Dm)) )
#define vuzp_u8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20100, (Dd), (Dm)) )
#define vuzp_f32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vuzp_s32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vuzp_u32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vuzpq_f32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba0140, (Qd), (Qm)) )
#define vuzpq_p16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b60140, (Qd), (Qm)) )
#define vuzpq_p8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b20140, (Qd), (Qm)) )
#define vuzpq_s16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b60140, (Qd), (Qm)) )
#define vuzpq_s32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba0140, (Qd), (Qm)) )
#define vuzpq_s8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b20140, (Qd), (Qm)) )
#define vuzpq_u16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b60140, (Qd), (Qm)) )
#define vuzpq_u32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba0140, (Qd), (Qm)) )
#define vuzpq_u8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b20140, (Qd), (Qm)) )

// VZIP
#define vzip_p16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60180, (Dd), (Dm)) )
#define vzip_p8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20180, (Dd), (Dm)) )
#define vzip_s16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60180, (Dd), (Dm)) )
#define vzip_s8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20180, (Dd), (Dm)) )
#define vzip_u16(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3b60180, (Dd), (Dm)) )
#define vzip_u8(Dd, Dm)                          ( __neon_DdDm_acc2( 0xf3b20180, (Dd), (Dm)) )
#define vzip_f32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vzip_s32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vzip_u32(Dd, Dm)                         ( __neon_DdDm_acc2( 0xf3ba0080, (Dd), (Dm)) )
#define vzipq_f32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba01c0, (Qd), (Qm)) )
#define vzipq_p16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b601c0, (Qd), (Qm)) )
#define vzipq_p8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b201c0, (Qd), (Qm)) )
#define vzipq_s16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b601c0, (Qd), (Qm)) )
#define vzipq_s32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba01c0, (Qd), (Qm)) )
#define vzipq_s8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b201c0, (Qd), (Qm)) )
#define vzipq_u16(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3b601c0, (Qd), (Qm)) )
#define vzipq_u32(Qd, Qm)                        ( __neon_QdQm_acc2( 0xf3ba01c0, (Qd), (Qm)) )
#define vzipq_u8(Qd, Qm)                         ( __neon_QdQm_acc2( 0xf3b201c0, (Qd), (Qm)) )

// } +++ auto-generated code ends (Neon macros)



///////////////////////////////////////////////////////////////////////////////
//
// { +++ auto-generated code begins (vreinterpret macros)

#define vreinterpret_f32_s8(a)         (a)
#define vreinterpret_f32_s16(a)        (a)
#define vreinterpret_f32_s32(a)        (a)
#define vreinterpret_f32_s64(a)        (a)
#define vreinterpret_f32_p8(a)         (a)
#define vreinterpret_f32_p16(a)        (a)
#define vreinterpret_f32_u8(a)         (a)
#define vreinterpret_f32_u16(a)        (a)
#define vreinterpret_f32_u32(a)        (a)
#define vreinterpret_f32_u64(a)        (a)
#define vreinterpret_s8_f32(a)         (a)
#define vreinterpret_s8_s16(a)         (a)
#define vreinterpret_s8_s32(a)         (a)
#define vreinterpret_s8_s64(a)         (a)
#define vreinterpret_s8_p8(a)          (a)
#define vreinterpret_s8_p16(a)         (a)
#define vreinterpret_s8_u8(a)          (a)
#define vreinterpret_s8_u16(a)         (a)
#define vreinterpret_s8_u32(a)         (a)
#define vreinterpret_s8_u64(a)         (a)
#define vreinterpret_s16_f32(a)        (a)
#define vreinterpret_s16_s8(a)         (a)
#define vreinterpret_s16_s32(a)        (a)
#define vreinterpret_s16_s64(a)        (a)
#define vreinterpret_s16_p8(a)         (a)
#define vreinterpret_s16_p16(a)        (a)
#define vreinterpret_s16_u8(a)         (a)
#define vreinterpret_s16_u16(a)        (a)
#define vreinterpret_s16_u32(a)        (a)
#define vreinterpret_s16_u64(a)        (a)
#define vreinterpret_s32_f32(a)        (a)
#define vreinterpret_s32_s8(a)         (a)
#define vreinterpret_s32_s16(a)        (a)
#define vreinterpret_s32_s64(a)        (a)
#define vreinterpret_s32_p8(a)         (a)
#define vreinterpret_s32_p16(a)        (a)
#define vreinterpret_s32_u8(a)         (a)
#define vreinterpret_s32_u16(a)        (a)
#define vreinterpret_s32_u32(a)        (a)
#define vreinterpret_s32_u64(a)        (a)
#define vreinterpret_s64_f32(a)        (a)
#define vreinterpret_s64_s8(a)         (a)
#define vreinterpret_s64_s16(a)        (a)
#define vreinterpret_s64_s32(a)        (a)
#define vreinterpret_s64_p8(a)         (a)
#define vreinterpret_s64_p16(a)        (a)
#define vreinterpret_s64_u8(a)         (a)
#define vreinterpret_s64_u16(a)        (a)
#define vreinterpret_s64_u32(a)        (a)
#define vreinterpret_s64_u64(a)        (a)
#define vreinterpret_p8_f32(a)         (a)
#define vreinterpret_p8_s8(a)          (a)
#define vreinterpret_p8_s16(a)         (a)
#define vreinterpret_p8_s32(a)         (a)
#define vreinterpret_p8_s64(a)         (a)
#define vreinterpret_p8_p16(a)         (a)
#define vreinterpret_p8_u8(a)          (a)
#define vreinterpret_p8_u16(a)         (a)
#define vreinterpret_p8_u32(a)         (a)
#define vreinterpret_p8_u64(a)         (a)
#define vreinterpret_p16_f32(a)        (a)
#define vreinterpret_p16_s8(a)         (a)
#define vreinterpret_p16_s16(a)        (a)
#define vreinterpret_p16_s32(a)        (a)
#define vreinterpret_p16_s64(a)        (a)
#define vreinterpret_p16_p8(a)         (a)
#define vreinterpret_p16_u8(a)         (a)
#define vreinterpret_p16_u16(a)        (a)
#define vreinterpret_p16_u32(a)        (a)
#define vreinterpret_p16_u64(a)        (a)
#define vreinterpret_u8_f32(a)         (a)
#define vreinterpret_u8_s8(a)          (a)
#define vreinterpret_u8_s16(a)         (a)
#define vreinterpret_u8_s32(a)         (a)
#define vreinterpret_u8_s64(a)         (a)
#define vreinterpret_u8_p8(a)          (a)
#define vreinterpret_u8_p16(a)         (a)
#define vreinterpret_u8_u16(a)         (a)
#define vreinterpret_u8_u32(a)         (a)
#define vreinterpret_u8_u64(a)         (a)
#define vreinterpret_u16_f32(a)        (a)
#define vreinterpret_u16_s8(a)         (a)
#define vreinterpret_u16_s16(a)        (a)
#define vreinterpret_u16_s32(a)        (a)
#define vreinterpret_u16_s64(a)        (a)
#define vreinterpret_u16_p8(a)         (a)
#define vreinterpret_u16_p16(a)        (a)
#define vreinterpret_u16_u8(a)         (a)
#define vreinterpret_u16_u32(a)        (a)
#define vreinterpret_u16_u64(a)        (a)
#define vreinterpret_u32_f32(a)        (a)
#define vreinterpret_u32_s8(a)         (a)
#define vreinterpret_u32_s16(a)        (a)
#define vreinterpret_u32_s32(a)        (a)
#define vreinterpret_u32_s64(a)        (a)
#define vreinterpret_u32_p8(a)         (a)
#define vreinterpret_u32_p16(a)        (a)
#define vreinterpret_u32_u8(a)         (a)
#define vreinterpret_u32_u16(a)        (a)
#define vreinterpret_u32_u64(a)        (a)
#define vreinterpret_u64_f32(a)        (a)
#define vreinterpret_u64_s8(a)         (a)
#define vreinterpret_u64_s16(a)        (a)
#define vreinterpret_u64_s32(a)        (a)
#define vreinterpret_u64_s64(a)        (a)
#define vreinterpret_u64_p8(a)         (a)
#define vreinterpret_u64_p16(a)        (a)
#define vreinterpret_u64_u8(a)         (a)
#define vreinterpret_u64_u16(a)        (a)
#define vreinterpret_u64_u32(a)        (a)
#define vreinterpretq_f32_s8(a)        (a)
#define vreinterpretq_f32_s16(a)       (a)
#define vreinterpretq_f32_s32(a)       (a)
#define vreinterpretq_f32_s64(a)       (a)
#define vreinterpretq_f32_p8(a)        (a)
#define vreinterpretq_f32_p16(a)       (a)
#define vreinterpretq_f32_u8(a)        (a)
#define vreinterpretq_f32_u16(a)       (a)
#define vreinterpretq_f32_u32(a)       (a)
#define vreinterpretq_f32_u64(a)       (a)
#define vreinterpretq_s8_f32(a)        (a)
#define vreinterpretq_s8_s16(a)        (a)
#define vreinterpretq_s8_s32(a)        (a)
#define vreinterpretq_s8_s64(a)        (a)
#define vreinterpretq_s8_p8(a)         (a)
#define vreinterpretq_s8_p16(a)        (a)
#define vreinterpretq_s8_u8(a)         (a)
#define vreinterpretq_s8_u16(a)        (a)
#define vreinterpretq_s8_u32(a)        (a)
#define vreinterpretq_s8_u64(a)        (a)
#define vreinterpretq_s16_f32(a)       (a)
#define vreinterpretq_s16_s8(a)        (a)
#define vreinterpretq_s16_s32(a)       (a)
#define vreinterpretq_s16_s64(a)       (a)
#define vreinterpretq_s16_p8(a)        (a)
#define vreinterpretq_s16_p16(a)       (a)
#define vreinterpretq_s16_u8(a)        (a)
#define vreinterpretq_s16_u16(a)       (a)
#define vreinterpretq_s16_u32(a)       (a)
#define vreinterpretq_s16_u64(a)       (a)
#define vreinterpretq_s32_f32(a)       (a)
#define vreinterpretq_s32_s8(a)        (a)
#define vreinterpretq_s32_s16(a)       (a)
#define vreinterpretq_s32_s64(a)       (a)
#define vreinterpretq_s32_p8(a)        (a)
#define vreinterpretq_s32_p16(a)       (a)
#define vreinterpretq_s32_u8(a)        (a)
#define vreinterpretq_s32_u16(a)       (a)
#define vreinterpretq_s32_u32(a)       (a)
#define vreinterpretq_s32_u64(a)       (a)
#define vreinterpretq_s64_f32(a)       (a)
#define vreinterpretq_s64_s8(a)        (a)
#define vreinterpretq_s64_s16(a)       (a)
#define vreinterpretq_s64_s32(a)       (a)
#define vreinterpretq_s64_p8(a)        (a)
#define vreinterpretq_s64_p16(a)       (a)
#define vreinterpretq_s64_u8(a)        (a)
#define vreinterpretq_s64_u16(a)       (a)
#define vreinterpretq_s64_u32(a)       (a)
#define vreinterpretq_s64_u64(a)       (a)
#define vreinterpretq_p8_f32(a)        (a)
#define vreinterpretq_p8_s8(a)         (a)
#define vreinterpretq_p8_s16(a)        (a)
#define vreinterpretq_p8_s32(a)        (a)
#define vreinterpretq_p8_s64(a)        (a)
#define vreinterpretq_p8_p16(a)        (a)
#define vreinterpretq_p8_u8(a)         (a)
#define vreinterpretq_p8_u16(a)        (a)
#define vreinterpretq_p8_u32(a)        (a)
#define vreinterpretq_p8_u64(a)        (a)
#define vreinterpretq_p16_f32(a)       (a)
#define vreinterpretq_p16_s8(a)        (a)
#define vreinterpretq_p16_s16(a)       (a)
#define vreinterpretq_p16_s32(a)       (a)
#define vreinterpretq_p16_s64(a)       (a)
#define vreinterpretq_p16_p8(a)        (a)
#define vreinterpretq_p16_u8(a)        (a)
#define vreinterpretq_p16_u16(a)       (a)
#define vreinterpretq_p16_u32(a)       (a)
#define vreinterpretq_p16_u64(a)       (a)
#define vreinterpretq_u8_f32(a)        (a)
#define vreinterpretq_u8_s8(a)         (a)
#define vreinterpretq_u8_s16(a)        (a)
#define vreinterpretq_u8_s32(a)        (a)
#define vreinterpretq_u8_s64(a)        (a)
#define vreinterpretq_u8_p8(a)         (a)
#define vreinterpretq_u8_p16(a)        (a)
#define vreinterpretq_u8_u16(a)        (a)
#define vreinterpretq_u8_u32(a)        (a)
#define vreinterpretq_u8_u64(a)        (a)
#define vreinterpretq_u16_f32(a)       (a)
#define vreinterpretq_u16_s8(a)        (a)
#define vreinterpretq_u16_s16(a)       (a)
#define vreinterpretq_u16_s32(a)       (a)
#define vreinterpretq_u16_s64(a)       (a)
#define vreinterpretq_u16_p8(a)        (a)
#define vreinterpretq_u16_p16(a)       (a)
#define vreinterpretq_u16_u8(a)        (a)
#define vreinterpretq_u16_u32(a)       (a)
#define vreinterpretq_u16_u64(a)       (a)
#define vreinterpretq_u32_f32(a)       (a)
#define vreinterpretq_u32_s8(a)        (a)
#define vreinterpretq_u32_s16(a)       (a)
#define vreinterpretq_u32_s32(a)       (a)
#define vreinterpretq_u32_s64(a)       (a)
#define vreinterpretq_u32_p8(a)        (a)
#define vreinterpretq_u32_p16(a)       (a)
#define vreinterpretq_u32_u8(a)        (a)
#define vreinterpretq_u32_u16(a)       (a)
#define vreinterpretq_u32_u64(a)       (a)
#define vreinterpretq_u64_f32(a)       (a)
#define vreinterpretq_u64_s8(a)        (a)
#define vreinterpretq_u64_s16(a)       (a)
#define vreinterpretq_u64_s32(a)       (a)
#define vreinterpretq_u64_s64(a)       (a)
#define vreinterpretq_u64_p8(a)        (a)
#define vreinterpretq_u64_p16(a)       (a)
#define vreinterpretq_u64_u8(a)        (a)
#define vreinterpretq_u64_u16(a)       (a)
#define vreinterpretq_u64_u32(a)       (a)

// } +++ auto-generated code ends (vreinterpret macros)

// { +++ auto-generated code begins (Pseudo intrinsics)

//  Multiply by scalar
#define vmul_n_s16(Vd, Rt)             vmul_lane_s16((Vd), vmov_n_s16(Rt), 0)
#define vmul_n_s32(Vd, Rt)             vmul_lane_s32((Vd), vmov_n_s32(Rt), 0)
#define vmul_n_u16(Vd, Rt)             vmul_lane_u16((Vd), vmov_n_u16(Rt), 0)
#define vmul_n_u32(Vd, Rt)             vmul_lane_u32((Vd), vmov_n_u32(Rt), 0)
#define vmulq_n_s16(Vd, Rt)            vmulq_lane_s16((Vd), vmov_n_s16(Rt), 0)
#define vmulq_n_s32(Vd, Rt)            vmulq_lane_s32((Vd), vmov_n_s32(Rt), 0)
#define vmulq_n_u16(Vd, Rt)            vmulq_lane_u16((Vd), vmov_n_u16(Rt), 0)
#define vmulq_n_u32(Vd, Rt)            vmulq_lane_u32((Vd), vmov_n_u32(Rt), 0)
#define vmull_n_s16(Vd, Rt)            vmull_lane_s16((Vd), vmov_n_s16(Rt), 0)
#define vmull_n_s32(Vd, Rt)            vmull_lane_s32((Vd), vmov_n_s32(Rt), 0)
#define vmull_n_u16(Vd, Rt)            vmull_lane_u16((Vd), vmov_n_u16(Rt), 0)
#define vmull_n_u32(Vd, Rt)            vmull_lane_u32((Vd), vmov_n_u32(Rt), 0)
#define vqdmulh_n_s16(Vd, Rt)          vqdmulh_lane_s16((Vd), vmov_n_s16(Rt), 0)
#define vqdmulh_n_s32(Vd, Rt)          vqdmulh_lane_s32((Vd), vmov_n_s32(Rt), 0)
#define vqdmulhq_n_s16(Vd, Rt)         vqdmulhq_lane_s16((Vd), vmov_n_s16(Rt), 0)
#define vqdmulhq_n_s32(Vd, Rt)         vqdmulhq_lane_s32((Vd), vmov_n_s32(Rt), 0)
#define vqdmull_n_s16(Vd, Rt)          vqdmull_lane_s16((Vd), vmov_n_s16(Rt), 0)
#define vqdmull_n_s32(Vd, Rt)          vqdmull_lane_s32((Vd), vmov_n_s32(Rt), 0)
#define vqrdmulh_n_s16(Vd, Rt)         vqrdmulh_lane_s16((Vd), vmov_n_s16(Rt), 0)
#define vqrdmulh_n_s32(Vd, Rt)         vqrdmulh_lane_s32((Vd), vmov_n_s32(Rt), 0)
#define vqrdmulhq_n_s16(Vd, Rt)        vqrdmulhq_lane_s16((Vd), vmov_n_s16(Rt), 0)
#define vqrdmulhq_n_s32(Vd, Rt)        vqrdmulhq_lane_s32((Vd), vmov_n_s32(Rt), 0)

//  Multiply by scalar with accumulate
#define vmla_n_s16(Vd, Vn, Rt)         vmla_lane_s16((Vd), (Vn), vmov_n_s16(Rt), 0)
#define vmla_n_s32(Vd, Vn, Rt)         vmla_lane_s32((Vd), (Vn), vmov_n_s32(Rt), 0)
#define vmla_n_u16(Vd, Vn, Rt)         vmla_lane_u16((Vd), (Vn), vmov_n_u16(Rt), 0)
#define vmla_n_u32(Vd, Vn, Rt)         vmla_lane_u32((Vd), (Vn), vmov_n_u32(Rt), 0)
#define vmlaq_n_s16(Vd, Vn, Rt)        vmlaq_lane_s16((Vd), (Vn), vmov_n_s16(Rt), 0)
#define vmlaq_n_s32(Vd, Vn, Rt)        vmlaq_lane_s32((Vd), (Vn), vmov_n_s32(Rt), 0)
#define vmlaq_n_u16(Vd, Vn, Rt)        vmlaq_lane_u16((Vd), (Vn), vmov_n_u16(Rt), 0)
#define vmlaq_n_u32(Vd, Vn, Rt)        vmlaq_lane_u32((Vd), (Vn), vmov_n_u32(Rt), 0)
#define vmlal_n_s16(Vd, Vn, Rt)        vmlal_lane_s16((Vd), (Vn), vmov_n_s16(Rt), 0)
#define vmlal_n_s32(Vd, Vn, Rt)        vmlal_lane_s32((Vd), (Vn), vmov_n_s32(Rt), 0)
#define vmlal_n_u16(Vd, Vn, Rt)        vmlal_lane_u16((Vd), (Vn), vmov_n_u16(Rt), 0)
#define vmlal_n_u32(Vd, Vn, Rt)        vmlal_lane_u32((Vd), (Vn), vmov_n_u32(Rt), 0)
#define vmls_n_s16(Vd, Vn, Rt)         vmls_lane_s16((Vd), (Vn), vmov_n_s16(Rt), 0)
#define vmls_n_s32(Vd, Vn, Rt)         vmls_lane_s32((Vd), (Vn), vmov_n_s32(Rt), 0)
#define vmls_n_u16(Vd, Vn, Rt)         vmls_lane_u16((Vd), (Vn), vmov_n_u16(Rt), 0)
#define vmls_n_u32(Vd, Vn, Rt)         vmls_lane_u32((Vd), (Vn), vmov_n_u32(Rt), 0)
#define vmlsq_n_s16(Vd, Vn, Rt)        vmlsq_lane_s16((Vd), (Vn), vmov_n_s16(Rt), 0)
#define vmlsq_n_s32(Vd, Vn, Rt)        vmlsq_lane_s32((Vd), (Vn), vmov_n_s32(Rt), 0)
#define vmlsq_n_u16(Vd, Vn, Rt)        vmlsq_lane_u16((Vd), (Vn), vmov_n_u16(Rt), 0)
#define vmlsq_n_u32(Vd, Vn, Rt)        vmlsq_lane_u32((Vd), (Vn), vmov_n_u32(Rt), 0)
#define vmlsl_n_s16(Vd, Vn, Rt)        vmlsl_lane_s16((Vd), (Vn), vmov_n_s16(Rt), 0)
#define vmlsl_n_s32(Vd, Vn, Rt)        vmlsl_lane_s32((Vd), (Vn), vmov_n_s32(Rt), 0)
#define vmlsl_n_u16(Vd, Vn, Rt)        vmlsl_lane_u16((Vd), (Vn), vmov_n_u16(Rt), 0)
#define vmlsl_n_u32(Vd, Vn, Rt)        vmlsl_lane_u32((Vd), (Vn), vmov_n_u32(Rt), 0)
#define vqdmlal_n_s16(Vd, Vn, Rt)      vqdmlal_lane_s16((Vd), (Vn), vmov_n_s16(Rt), 0)
#define vqdmlal_n_s32(Vd, Vn, Rt)      vqdmlal_lane_s32((Vd), (Vn), vmov_n_s32(Rt), 0)
#define vqdmlsl_n_s16(Vd, Vn, Rt)      vqdmlsl_lane_s16((Vd), (Vn), vmov_n_s16(Rt), 0)
#define vqdmlsl_n_s32(Vd, Vn, Rt)      vqdmlsl_lane_s32((Vd), (Vn), vmov_n_s32(Rt), 0)

//  VDUP.64 (scalar)
#define vdup_lane_s64(Dn, lane)        (__static_assert((lane) == 0, "invalid lane index"), (Dn))
#define vdup_lane_u64(Dn, lane)        (__static_assert((lane) == 0, "invalid lane index"), (Dn))

//  VDUP.W.64 (scalar)
#define vdupq_lane_s64(Dn, lane)       (__static_assert((lane) == 0, "invalid lane index"), vcombine_s64((Dn), (Dn)))
#define vdupq_lane_u64(Dn, lane)       (__static_assert((lane) == 0, "invalid lane index"), vcombine_u64((Dn), (Dn)))

// } +++ auto-generated code ends (Pseudo intrinsics)

#else // defined(_ARM_USE_DEPRECATED_NEON_INTRINSICS)

#if defined (__cplusplus)
extern "C" {
#endif  /* defined (__cplusplus) */

__n128 __aesd_p8(__n128 _Qd, __n128 _Qm);
__n128 __aesd_s8(__n128 _Qd, __n128 _Qm);
__n128 __aesd_u8(__n128 _Qd, __n128 _Qm);
__n128 __aese_p8(__n128 _Qd, __n128 _Qm);
__n128 __aese_s8(__n128 _Qd, __n128 _Qm);
__n128 __aese_u8(__n128 _Qd, __n128 _Qm);
__n128 __aesimc_p8(__n128 _Qm);
__n128 __aesimc_s8(__n128 _Qm);
__n128 __aesimc_u8(__n128 _Qm);
__n128 __aesmc_p8(__n128 _Qm);
__n128 __aesmc_s8(__n128 _Qm);
__n128 __aesmc_u8(__n128 _Qm);
__n128 __sha1h_f32(__n128 _Qm);
__n128 __sha1h_s32(__n128 _Qm);
__n128 __sha1h_u32(__n128 _Qm);
__n128 __sha1su1_f32(__n128 _Qd, __n128 _Qm);
__n128 __sha1su1_s32(__n128 _Qd, __n128 _Qm);
__n128 __sha1su1_u32(__n128 _Qd, __n128 _Qm);
__n128 __sha256su0_f32(__n128 _Qd, __n128 _Qm);
__n128 __sha256su0_s32(__n128 _Qd, __n128 _Qm);
__n128 __sha256su0_u32(__n128 _Qd, __n128 _Qm);
__n128 __sha1c_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1c_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1c_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1m_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1m_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1m_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1p_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1p_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1p_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1su0_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1su0_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha1su0_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256h_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256h_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256h_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256h2_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256h2_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256h2_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256su1_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256su1_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __sha256su1_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n64 __vaba_s16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vaba_s32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vaba_s8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vaba_u16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vaba_u32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vaba_u8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n128 __vabal_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vabal_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vabal_s8(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vabal_u16(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vabal_u32(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vabal_u8(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vabaq_s16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vabaq_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vabaq_s8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vabaq_u16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vabaq_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vabaq_u8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n64 __vabd_f32(__n64 _Dn, __n64 _Dm);
__n128 __vabdq_f32(__n128 _Qn, __n128 _Qm);
__n64 __vabd_s16(__n64 _Dn, __n64 _Dm);
__n64 __vabd_s32(__n64 _Dn, __n64 _Dm);
__n64 __vabd_s8(__n64 _Dn, __n64 _Dm);
__n64 __vabd_u16(__n64 _Dn, __n64 _Dm);
__n64 __vabd_u32(__n64 _Dn, __n64 _Dm);
__n64 __vabd_u8(__n64 _Dn, __n64 _Dm);
__n128 __vabdl_s16(__n64 _Dn, __n64 _Dm);
__n128 __vabdl_s32(__n64 _Dn, __n64 _Dm);
__n128 __vabdl_s8(__n64 _Dn, __n64 _Dm);
__n128 __vabdl_u16(__n64 _Dn, __n64 _Dm);
__n128 __vabdl_u32(__n64 _Dn, __n64 _Dm);
__n128 __vabdl_u8(__n64 _Dn, __n64 _Dm);
__n128 __vabdq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vabdq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vabdq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vabdq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vabdq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vabdq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vabs_f32(__n64 _Dm);
__n64 __vabs_s16(__n64 _Dm);
__n64 __vabs_s32(__n64 _Dm);
__n64 __vabs_s8(__n64 _Dm);
__n64 __vneg_f32(__n64 _Dm);
__n64 __vneg_s16(__n64 _Dm);
__n64 __vneg_s32(__n64 _Dm);
__n64 __vneg_s8(__n64 _Dm);
__n128 __vabsq_f32(__n128 _Qm);
__n128 __vabsq_s16(__n128 _Qm);
__n128 __vabsq_s32(__n128 _Qm);
__n128 __vabsq_s8(__n128 _Qm);
__n128 __vnegq_f32(__n128 _Qm);
__n128 __vnegq_s16(__n128 _Qm);
__n128 __vnegq_s32(__n128 _Qm);
__n128 __vnegq_s8(__n128 _Qm);
__n64 __vacge_f32(__n64 _Dn, __n64 _Dm);
__n64 __vacgt_f32(__n64 _Dn, __n64 _Dm);
__n64 __vacle_f32(__n64 _Dn, __n64 _Dm);
__n64 __vaclt_f32(__n64 _Dn, __n64 _Dm);
__n128 __vacgeq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vacgtq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vacleq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vacltq_f32(__n128 _Qn, __n128 _Qm);
__n64 __vadd_f32(__n64 _Dn, __n64 _Dm);
__n64 __vadd_s16(__n64 _Dn, __n64 _Dm);
__n64 __vadd_s32(__n64 _Dn, __n64 _Dm);
__n64 __vadd_s64(__n64 _Dn, __n64 _Dm);
__n64 __vadd_s8(__n64 _Dn, __n64 _Dm);
__n64 __vadd_u16(__n64 _Dn, __n64 _Dm);
__n64 __vadd_u32(__n64 _Dn, __n64 _Dm);
__n64 __vadd_u64(__n64 _Dn, __n64 _Dm);
__n64 __vadd_u8(__n64 _Dn, __n64 _Dm);
__n128 __vaddq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vaddq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vaddq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vaddq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vaddq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vaddq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vaddq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vaddq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vaddq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vaddhn_s16(__n128 _Qn, __n128 _Qm);
__n64 __vaddhn_s32(__n128 _Qn, __n128 _Qm);
__n64 __vaddhn_s64(__n128 _Qn, __n128 _Qm);
__n64 __vaddhn_u16(__n128 _Qn, __n128 _Qm);
__n64 __vaddhn_u32(__n128 _Qn, __n128 _Qm);
__n64 __vaddhn_u64(__n128 _Qn, __n128 _Qm);
__n64 __vraddhn_s16(__n128 _Qn, __n128 _Qm);
__n64 __vraddhn_s32(__n128 _Qn, __n128 _Qm);
__n64 __vraddhn_s64(__n128 _Qn, __n128 _Qm);
__n64 __vraddhn_u16(__n128 _Qn, __n128 _Qm);
__n64 __vraddhn_u32(__n128 _Qn, __n128 _Qm);
__n64 __vraddhn_u64(__n128 _Qn, __n128 _Qm);
__n128 __vaddl_s16(__n64 _Dn, __n64 _Dm);
__n128 __vaddl_s32(__n64 _Dn, __n64 _Dm);
__n128 __vaddl_s8(__n64 _Dn, __n64 _Dm);
__n128 __vaddl_u16(__n64 _Dn, __n64 _Dm);
__n128 __vaddl_u32(__n64 _Dn, __n64 _Dm);
__n128 __vaddl_u8(__n64 _Dn, __n64 _Dm);
__n128 __vaddw_s16(__n128 _Qn, __n64 _Dm);
__n128 __vaddw_s32(__n128 _Qn, __n64 _Dm);
__n128 __vaddw_s8(__n128 _Qn, __n64 _Dm);
__n128 __vaddw_u16(__n128 _Qn, __n64 _Dm);
__n128 __vaddw_u32(__n128 _Qn, __n64 _Dm);
__n128 __vaddw_u8(__n128 _Qn, __n64 _Dm);
__n64 __vand_s16(__n64 _Dn, __n64 _Dm);
__n64 __vand_s32(__n64 _Dn, __n64 _Dm);
__n64 __vand_s64(__n64 _Dn, __n64 _Dm);
__n64 __vand_s8(__n64 _Dn, __n64 _Dm);
__n64 __vand_u16(__n64 _Dn, __n64 _Dm);
__n64 __vand_u32(__n64 _Dn, __n64 _Dm);
__n64 __vand_u64(__n64 _Dn, __n64 _Dm);
__n64 __vand_u8(__n64 _Dn, __n64 _Dm);
__n64 __vorr_s16(__n64 _Dn, __n64 _Dm);
__n64 __vorr_s32(__n64 _Dn, __n64 _Dm);
__n64 __vorr_s64(__n64 _Dn, __n64 _Dm);
__n64 __vorr_s8(__n64 _Dn, __n64 _Dm);
__n64 __vorr_u16(__n64 _Dn, __n64 _Dm);
__n64 __vorr_u32(__n64 _Dn, __n64 _Dm);
__n64 __vorr_u64(__n64 _Dn, __n64 _Dm);
__n64 __vorr_u8(__n64 _Dn, __n64 _Dm);
__n128 __vandq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vandq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vandq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vandq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vandq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vandq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vandq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vandq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vorrq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vorrq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vorrq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vorrq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vorrq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vorrq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vorrq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vorrq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vbif_f32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_p16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_p8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_s16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_s32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_s64(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_s8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_u16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_u32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_u64(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbif_u8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_f32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_p16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_p8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_s16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_s32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_s64(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_s8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_u16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_u32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_u64(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbit_u8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_f32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_p16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_p8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_s16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_s32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_s64(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_s8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_u16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_u32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_u64(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vbsl_u8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n128 __vbifq_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_p16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_p8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_s16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_s64(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_s8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_u16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_u64(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbifq_u8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_p16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_p8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_s16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_s64(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_s8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_u16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_u64(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbitq_u8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_p16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_p8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_s16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_s64(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_s8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_u16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_u64(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vbslq_u8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n64 __vceq_z_f32_ex(__n64 _Dm);
__n64 __vceq_z_s16_ex(__n64 _Dm);
__n64 __vceq_z_s32_ex(__n64 _Dm);
__n64 __vceq_z_s8_ex(__n64 _Dm);
__n64 __vceq_z_u16_ex(__n64 _Dm);
__n64 __vceq_z_u32_ex(__n64 _Dm);
__n64 __vceq_z_u8_ex(__n64 _Dm);
__n128 __vceqq_z_f32_ex(__n128 _Qm);
__n128 __vceqq_z_s16_ex(__n128 _Qm);
__n128 __vceqq_z_s32_ex(__n128 _Qm);
__n128 __vceqq_z_s8_ex(__n128 _Qm);
__n128 __vceqq_z_u16_ex(__n128 _Qm);
__n128 __vceqq_z_u32_ex(__n128 _Qm);
__n128 __vceqq_z_u8_ex(__n128 _Qm);
__n64 __vceq_f32(__n64 _Dn, __n64 _Dm);
__n64 __vceq_p8(__n64 _Dn, __n64 _Dm);
__n64 __vceq_s16(__n64 _Dn, __n64 _Dm);
__n64 __vceq_s32(__n64 _Dn, __n64 _Dm);
__n64 __vceq_s8(__n64 _Dn, __n64 _Dm);
__n64 __vceq_u16(__n64 _Dn, __n64 _Dm);
__n64 __vceq_u32(__n64 _Dn, __n64 _Dm);
__n64 __vceq_u8(__n64 _Dn, __n64 _Dm);
__n128 __vceqq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vceqq_p8(__n128 _Qn, __n128 _Qm);
__n128 __vceqq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vceqq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vceqq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vceqq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vceqq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vceqq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vcge_z_f32_ex(__n64 _Dm);
__n64 __vcge_z_s16_ex(__n64 _Dm);
__n64 __vcge_z_s32_ex(__n64 _Dm);
__n64 __vcge_z_s8_ex(__n64 _Dm);
__n128 __vcgeq_z_f32_ex(__n128 _Qm);
__n128 __vcgeq_z_s16_ex(__n128 _Qm);
__n128 __vcgeq_z_s32_ex(__n128 _Qm);
__n128 __vcgeq_z_s8_ex(__n128 _Qm);
__n64 __vcge_f32(__n64 _Dn, __n64 _Dm);
__n64 __vcge_s16(__n64 _Dn, __n64 _Dm);
__n64 __vcge_s32(__n64 _Dn, __n64 _Dm);
__n64 __vcge_s8(__n64 _Dn, __n64 _Dm);
__n64 __vcge_u16(__n64 _Dn, __n64 _Dm);
__n64 __vcge_u32(__n64 _Dn, __n64 _Dm);
__n64 __vcge_u8(__n64 _Dn, __n64 _Dm);
__n64 __vcle_f32(__n64 _Dn, __n64 _Dm);
__n64 __vcle_s16(__n64 _Dn, __n64 _Dm);
__n64 __vcle_s32(__n64 _Dn, __n64 _Dm);
__n64 __vcle_s8(__n64 _Dn, __n64 _Dm);
__n64 __vcle_u16(__n64 _Dn, __n64 _Dm);
__n64 __vcle_u32(__n64 _Dn, __n64 _Dm);
__n64 __vcle_u8(__n64 _Dn, __n64 _Dm);
__n128 __vcgeq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vcgeq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vcgeq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vcgeq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vcgeq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vcgeq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vcgeq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vcleq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vcleq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vcleq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vcleq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vcleq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vcleq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vcleq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vcgt_z_f32_ex(__n64 _Dm);
__n64 __vcgt_z_s16_ex(__n64 _Dm);
__n64 __vcgt_z_s32_ex(__n64 _Dm);
__n64 __vcgt_z_s8_ex(__n64 _Dm);
__n128 __vcgtq_z_f32_ex(__n128 _Qm);
__n128 __vcgtq_z_s16_ex(__n128 _Qm);
__n128 __vcgtq_z_s32_ex(__n128 _Qm);
__n128 __vcgtq_z_s8_ex(__n128 _Qm);
__n64 __vcgt_f32(__n64 _Dn, __n64 _Dm);
__n64 __vcgt_s16(__n64 _Dn, __n64 _Dm);
__n64 __vcgt_s32(__n64 _Dn, __n64 _Dm);
__n64 __vcgt_s8(__n64 _Dn, __n64 _Dm);
__n64 __vcgt_u16(__n64 _Dn, __n64 _Dm);
__n64 __vcgt_u32(__n64 _Dn, __n64 _Dm);
__n64 __vcgt_u8(__n64 _Dn, __n64 _Dm);
__n64 __vclt_f32(__n64 _Dn, __n64 _Dm);
__n64 __vclt_s16(__n64 _Dn, __n64 _Dm);
__n64 __vclt_s32(__n64 _Dn, __n64 _Dm);
__n64 __vclt_s8(__n64 _Dn, __n64 _Dm);
__n64 __vclt_u16(__n64 _Dn, __n64 _Dm);
__n64 __vclt_u32(__n64 _Dn, __n64 _Dm);
__n64 __vclt_u8(__n64 _Dn, __n64 _Dm);
__n128 __vcgtq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vcgtq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vcgtq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vcgtq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vcgtq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vcgtq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vcgtq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vcltq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vcltq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vcltq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vcltq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vcltq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vcltq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vcltq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vcle_z_f32_ex(__n64 _Dm);
__n64 __vcle_z_s16_ex(__n64 _Dm);
__n64 __vcle_z_s32_ex(__n64 _Dm);
__n64 __vcle_z_s8_ex(__n64 _Dm);
__n128 __vcleq_z_f32_ex(__n128 _Qm);
__n128 __vcleq_z_s16_ex(__n128 _Qm);
__n128 __vcleq_z_s32_ex(__n128 _Qm);
__n128 __vcleq_z_s8_ex(__n128 _Qm);
__n64 __vcls_s16(__n64 _Dm);
__n64 __vcls_s32(__n64 _Dm);
__n64 __vcls_s8(__n64 _Dm);
__n64 __vclz_s16(__n64 _Dm);
__n64 __vclz_s32(__n64 _Dm);
__n64 __vclz_s8(__n64 _Dm);
__n64 __vclz_u16(__n64 _Dm);
__n64 __vclz_u32(__n64 _Dm);
__n64 __vclz_u8(__n64 _Dm);
__n128 __vclsq_s16(__n128 _Qm);
__n128 __vclsq_s32(__n128 _Qm);
__n128 __vclsq_s8(__n128 _Qm);
__n128 __vclzq_s16(__n128 _Qm);
__n128 __vclzq_s32(__n128 _Qm);
__n128 __vclzq_s8(__n128 _Qm);
__n128 __vclzq_u16(__n128 _Qm);
__n128 __vclzq_u32(__n128 _Qm);
__n128 __vclzq_u8(__n128 _Qm);
__n64 __vclt_z_f32_ex(__n64 _Dm);
__n64 __vclt_z_s16_ex(__n64 _Dm);
__n64 __vclt_z_s32_ex(__n64 _Dm);
__n64 __vclt_z_s8_ex(__n64 _Dm);
__n128 __vcltq_z_f32_ex(__n128 _Qm);
__n128 __vcltq_z_s16_ex(__n128 _Qm);
__n128 __vcltq_z_s32_ex(__n128 _Qm);
__n128 __vcltq_z_s8_ex(__n128 _Qm);
__n64 __vcnt_p8(__n64 _Dm);
__n64 __vcnt_s8(__n64 _Dm);
__n64 __vcnt_u8(__n64 _Dm);
__n128 __vcntq_p8(__n128 _Qm);
__n128 __vcntq_s8(__n128 _Qm);
__n128 __vcntq_u8(__n128 _Qm);
__n128 __vcombine_f32(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_p16(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_p8(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_s16(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_s32(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_s64(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_s8(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_u16(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_u32(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_u64(__n64 _Dn, __n64 _Dm);
__n128 __vcombine_u8(__n64 _Dn, __n64 _Dm);
__n64 __vcreate_f32(uint64_t _R64t);
__n64 __vcreate_p16(uint64_t _R64t);
__n64 __vcreate_p8(uint64_t _R64t);
__n64 __vcreate_s16(uint64_t _R64t);
__n64 __vcreate_s32(uint64_t _R64t);
__n64 __vcreate_s64(uint64_t _R64t);
__n64 __vcreate_s8(uint64_t _R64t);
__n64 __vcreate_u16(uint64_t _R64t);
__n64 __vcreate_u32(uint64_t _R64t);
__n64 __vcreate_u64(uint64_t _R64t);
__n64 __vcreate_u8(uint64_t _R64t);
__n64 __vcvt_n_f32_s32(__n64 _Dm, const int _Fbits);
__n64 __vcvt_n_f32_u32(__n64 _Dm, const int _Fbits);
__n64 __vcvt_n_s32_f32(__n64 _Dm, const int _Fbits);
__n64 __vcvt_n_u32_f32(__n64 _Dm, const int _Fbits);
__n128 __vcvtq_n_f32_s32(__n128 _Qm, const int _Fbits);
__n128 __vcvtq_n_f32_u32(__n128 _Qm, const int _Fbits);
__n128 __vcvtq_n_s32_f32(__n128 _Qm, const int _Fbits);
__n128 __vcvtq_n_u32_f32(__n128 _Qm, const int _Fbits);
__n64 __vcvta_s32_f32(__n64 _Dm);
__n64 __vcvta_u32_f32(__n64 _Dm);
__n64 __vcvtm_s32_f32(__n64 _Dm);
__n64 __vcvtm_u32_f32(__n64 _Dm);
__n64 __vcvtn_s32_f32(__n64 _Dm);
__n64 __vcvtn_u32_f32(__n64 _Dm);
__n64 __vcvtp_s32_f32(__n64 _Dm);
__n64 __vcvtp_u32_f32(__n64 _Dm);
__n128 __vcvtaq_s32_f32(__n128 _Qm);
__n128 __vcvtaq_u32_f32(__n128 _Qm);
__n128 __vcvtmq_s32_f32(__n128 _Qm);
__n128 __vcvtmq_u32_f32(__n128 _Qm);
__n128 __vcvtnq_s32_f32(__n128 _Qm);
__n128 __vcvtnq_u32_f32(__n128 _Qm);
__n128 __vcvtpq_s32_f32(__n128 _Qm);
__n128 __vcvtpq_u32_f32(__n128 _Qm);
__n64 __vcvt_f32_s32(__n64 _Dm);
__n64 __vcvt_f32_u32(__n64 _Dm);
__n64 __vcvt_s32_f32(__n64 _Dm);
__n64 __vcvt_u32_f32(__n64 _Dm);
__n128 __vcvtq_f32_s32(__n128 _Qm);
__n128 __vcvtq_f32_u32(__n128 _Qm);
__n128 __vcvtq_s32_f32(__n128 _Qm);
__n128 __vcvtq_u32_f32(__n128 _Qm);
__n64 __vdup_lane_f32(__n64 _Dm, const int _Lane);
__n64 __vdup_lane_p16(__n64 _Dm, const int _Lane);
__n64 __vdup_lane_p8(__n64 _Dm, const int _Lane);
__n64 __vdup_lane_s16(__n64 _Dm, const int _Lane);
__n64 __vdup_lane_s32(__n64 _Dm, const int _Lane);
__n64 __vdup_lane_s8(__n64 _Dm, const int _Lane);
__n64 __vdup_lane_u16(__n64 _Dm, const int _Lane);
__n64 __vdup_lane_u32(__n64 _Dm, const int _Lane);
__n64 __vdup_lane_u8(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_f32(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_p16(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_p8(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_s16(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_s32(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_s8(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_u16(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_u32(__n64 _Dm, const int _Lane);
__n128 __vdupq_lane_u8(__n64 _Dm, const int _Lane);
__n64 __vdup_n_f32(float32_t _Ft);
__n64 __vmov_n_f32(float32_t _Ft);
__n64 __vdup_n_p16(poly16_t _Rt);
__n64 __vdup_n_p8(poly8_t _Rt);
__n64 __vdup_n_s16(int16_t _Rt);
__n64 __vdup_n_s32(int32_t _Rt);
__n64 __vdup_n_s8(int8_t _Rt);
__n64 __vdup_n_u16(uint16_t _Rt);
__n64 __vdup_n_u32(uint32_t _Rt);
__n64 __vdup_n_u8(uint8_t _Rt);
__n64 __vmov_n_p16(poly16_t _Rt);
__n64 __vmov_n_p8(poly8_t _Rt);
__n64 __vmov_n_s16(int16_t _Rt);
__n64 __vmov_n_s32(int32_t _Rt);
__n64 __vmov_n_s8(int8_t _Rt);
__n64 __vmov_n_u16(uint16_t _Rt);
__n64 __vmov_n_u32(uint32_t _Rt);
__n64 __vmov_n_u8(uint8_t _Rt);
__n128 __vdupq_n_f32(float32_t _Ft);
__n128 __vmovq_n_f32(float32_t _Ft);
__n128 __vdupq_n_p16(poly16_t _Rt);
__n128 __vdupq_n_p8(poly8_t _Rt);
__n128 __vdupq_n_s16(int16_t _Rt);
__n128 __vdupq_n_s32(int32_t _Rt);
__n128 __vdupq_n_s8(int8_t _Rt);
__n128 __vdupq_n_u16(uint16_t _Rt);
__n128 __vdupq_n_u32(uint32_t _Rt);
__n128 __vdupq_n_u8(uint8_t _Rt);
__n128 __vmovq_n_p16(poly16_t _Rt);
__n128 __vmovq_n_p8(poly8_t _Rt);
__n128 __vmovq_n_s16(int16_t _Rt);
__n128 __vmovq_n_s32(int32_t _Rt);
__n128 __vmovq_n_s8(int8_t _Rt);
__n128 __vmovq_n_u16(uint16_t _Rt);
__n128 __vmovq_n_u32(uint32_t _Rt);
__n128 __vmovq_n_u8(uint8_t _Rt);
__n64 __vdup_n_s64(int64_t _R64t);
__n64 __vdup_n_u64(uint64_t _R64t);
__n64 __vmov_n_s64(int64_t _R64t);
__n64 __vmov_n_u64(uint64_t _R64t);
__n128 __vdupq_n_s64(int64_t _R64t);
__n128 __vdupq_n_u64(uint64_t _R64t);
__n128 __vmovq_n_s64(int64_t _R64t);
__n128 __vmovq_n_u64(uint64_t _R64t);
__n64 __vbic_s16(__n64 _Dn, __n64 _Dm);
__n64 __vbic_s32(__n64 _Dn, __n64 _Dm);
__n64 __vbic_s64(__n64 _Dn, __n64 _Dm);
__n64 __vbic_s8(__n64 _Dn, __n64 _Dm);
__n64 __vbic_u16(__n64 _Dn, __n64 _Dm);
__n64 __vbic_u32(__n64 _Dn, __n64 _Dm);
__n64 __vbic_u64(__n64 _Dn, __n64 _Dm);
__n64 __vbic_u8(__n64 _Dn, __n64 _Dm);
__n64 __veor_s16(__n64 _Dn, __n64 _Dm);
__n64 __veor_s32(__n64 _Dn, __n64 _Dm);
__n64 __veor_s64(__n64 _Dn, __n64 _Dm);
__n64 __veor_s8(__n64 _Dn, __n64 _Dm);
__n64 __veor_u16(__n64 _Dn, __n64 _Dm);
__n64 __veor_u32(__n64 _Dn, __n64 _Dm);
__n64 __veor_u64(__n64 _Dn, __n64 _Dm);
__n64 __veor_u8(__n64 _Dn, __n64 _Dm);
__n64 __vorn_s16(__n64 _Dn, __n64 _Dm);
__n64 __vorn_s32(__n64 _Dn, __n64 _Dm);
__n64 __vorn_s64(__n64 _Dn, __n64 _Dm);
__n64 __vorn_s8(__n64 _Dn, __n64 _Dm);
__n64 __vorn_u16(__n64 _Dn, __n64 _Dm);
__n64 __vorn_u32(__n64 _Dn, __n64 _Dm);
__n64 __vorn_u64(__n64 _Dn, __n64 _Dm);
__n64 __vorn_u8(__n64 _Dn, __n64 _Dm);
__n128 __vbicq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vbicq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vbicq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vbicq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vbicq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vbicq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vbicq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vbicq_u8(__n128 _Qn, __n128 _Qm);
__n128 __veorq_s16(__n128 _Qn, __n128 _Qm);
__n128 __veorq_s32(__n128 _Qn, __n128 _Qm);
__n128 __veorq_s64(__n128 _Qn, __n128 _Qm);
__n128 __veorq_s8(__n128 _Qn, __n128 _Qm);
__n128 __veorq_u16(__n128 _Qn, __n128 _Qm);
__n128 __veorq_u32(__n128 _Qn, __n128 _Qm);
__n128 __veorq_u64(__n128 _Qn, __n128 _Qm);
__n128 __veorq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vornq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vornq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vornq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vornq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vornq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vornq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vornq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vornq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vext_f32(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_p16(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_p8(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_s16(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_s32(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_s64(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_s8(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_u16(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_u32(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_u64(__n64 _Dn, __n64 _Dm, const int _Pos);
__n64 __vext_u8(__n64 _Dn, __n64 _Dm, const int _Pos);
__n128 __vextq_f32(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_p16(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_p8(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_s16(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_s32(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_s64(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_s8(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_u16(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_u32(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_u64(__n128 _Qn, __n128 _Qm, const int _Pos);
__n128 __vextq_u8(__n128 _Qn, __n128 _Qm, const int _Pos);
__n64 __vget_high_f32(__n128 _Qm);
__n64 __vget_high_p16(__n128 _Qm);
__n64 __vget_high_p8(__n128 _Qm);
__n64 __vget_high_s16(__n128 _Qm);
__n64 __vget_high_s32(__n128 _Qm);
__n64 __vget_high_s64(__n128 _Qm);
__n64 __vget_high_s8(__n128 _Qm);
__n64 __vget_high_u16(__n128 _Qm);
__n64 __vget_high_u32(__n128 _Qm);
__n64 __vget_high_u64(__n128 _Qm);
__n64 __vget_high_u8(__n128 _Qm);
__n64 __vget_low_f32(__n128 _Qm);
__n64 __vget_low_p16(__n128 _Qm);
__n64 __vget_low_p8(__n128 _Qm);
__n64 __vget_low_s16(__n128 _Qm);
__n64 __vget_low_s32(__n128 _Qm);
__n64 __vget_low_s64(__n128 _Qm);
__n64 __vget_low_s8(__n128 _Qm);
__n64 __vget_low_u16(__n128 _Qm);
__n64 __vget_low_u32(__n128 _Qm);
__n64 __vget_low_u64(__n128 _Qm);
__n64 __vget_low_u8(__n128 _Qm);
__n64 __vhadd_s16(__n64 _Dn, __n64 _Dm);
__n64 __vhadd_s32(__n64 _Dn, __n64 _Dm);
__n64 __vhadd_s8(__n64 _Dn, __n64 _Dm);
__n64 __vhadd_u16(__n64 _Dn, __n64 _Dm);
__n64 __vhadd_u32(__n64 _Dn, __n64 _Dm);
__n64 __vhadd_u8(__n64 _Dn, __n64 _Dm);
__n64 __vhsub_s16(__n64 _Dn, __n64 _Dm);
__n64 __vhsub_s32(__n64 _Dn, __n64 _Dm);
__n64 __vhsub_s8(__n64 _Dn, __n64 _Dm);
__n64 __vhsub_u16(__n64 _Dn, __n64 _Dm);
__n64 __vhsub_u32(__n64 _Dn, __n64 _Dm);
__n64 __vhsub_u8(__n64 _Dn, __n64 _Dm);
__n64 __vrhadd_s16(__n64 _Dn, __n64 _Dm);
__n64 __vrhadd_s32(__n64 _Dn, __n64 _Dm);
__n64 __vrhadd_s8(__n64 _Dn, __n64 _Dm);
__n64 __vrhadd_u16(__n64 _Dn, __n64 _Dm);
__n64 __vrhadd_u32(__n64 _Dn, __n64 _Dm);
__n64 __vrhadd_u8(__n64 _Dn, __n64 _Dm);
__n128 __vhaddq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vhaddq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vhaddq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vhaddq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vhaddq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vhaddq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vhsubq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vhsubq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vhsubq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vhsubq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vhsubq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vhsubq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vrhaddq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vrhaddq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vrhaddq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vrhaddq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vrhaddq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vrhaddq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vld1_f32(_In_reads_(2) const float32_t * _PcD);
__n64 __vld1_p16(_In_reads_(4) const poly16_t * _PcD);
__n64 __vld1_p8(_In_reads_(8) const poly8_t * _PcD);
__n64 __vld1_s16(_In_reads_(4) const int16_t * _PcD);
__n64 __vld1_s32(_In_reads_(2) const int32_t * _PcD);
__n64 __vld1_s64(_In_reads_(1) const int64_t * _PcD);
__n64 __vld1_s8(_In_reads_(8) const int8_t * _PcD);
__n64 __vld1_u16(_In_reads_(4) const uint16_t * _PcD);
__n64 __vld1_u32(_In_reads_(2) const uint32_t * _PcD);
__n64 __vld1_u64(_In_reads_(1) const uint64_t * _PcD);
__n64 __vld1_u8(_In_reads_(8) const uint8_t * _PcD);
__n64 __vld1_f32_ex(_In_reads_(2) const float32_t * _PcD, const int _Align);
__n64 __vld1_p16_ex(_In_reads_(4) const poly16_t * _PcD, const int _Align);
__n64 __vld1_p8_ex(_In_reads_(8) const poly8_t * _PcD, const int _Align);
__n64 __vld1_s16_ex(_In_reads_(4) const int16_t * _PcD, const int _Align);
__n64 __vld1_s32_ex(_In_reads_(2) const int32_t * _PcD, const int _Align);
__n64 __vld1_s64_ex(_In_reads_(1) const int64_t * _PcD, const int _Align);
__n64 __vld1_s8_ex(_In_reads_(8) const int8_t * _PcD, const int _Align);
__n64 __vld1_u16_ex(_In_reads_(4) const uint16_t * _PcD, const int _Align);
__n64 __vld1_u32_ex(_In_reads_(2) const uint32_t * _PcD, const int _Align);
__n64 __vld1_u64_ex(_In_reads_(1) const uint64_t * _PcD, const int _Align);
__n64 __vld1_u8_ex(_In_reads_(8) const uint8_t * _PcD, const int _Align);
__n128 __vld1q_f32(_In_reads_(4) const float32_t * _PcD);
__n128 __vld1q_p16(_In_reads_(8) const poly16_t * _PcD);
__n128 __vld1q_p8(_In_reads_(16) const poly8_t * _PcD);
__n128 __vld1q_s16(_In_reads_(8) const int16_t * _PcD);
__n128 __vld1q_s32(_In_reads_(4) const int32_t * _PcD);
__n128 __vld1q_s64(_In_reads_(2) const int64_t * _PcD);
__n128 __vld1q_s8(_In_reads_(16) const int8_t * _PcD);
__n128 __vld1q_u16(_In_reads_(8) const uint16_t * _PcD);
__n128 __vld1q_u32(_In_reads_(4) const uint32_t * _PcD);
__n128 __vld1q_u64(_In_reads_(2) const uint64_t * _PcD);
__n128 __vld1q_u8(_In_reads_(16) const uint8_t * _PcD);
__n128 __vld1q_f32_ex(_In_reads_(4) const float32_t * _PcD, const int _Align);
__n128 __vld1q_p16_ex(_In_reads_(8) const poly16_t * _PcD, const int _Align);
__n128 __vld1q_p8_ex(_In_reads_(16) const poly8_t * _PcD, const int _Align);
__n128 __vld1q_s16_ex(_In_reads_(8) const int16_t * _PcD, const int _Align);
__n128 __vld1q_s32_ex(_In_reads_(4) const int32_t * _PcD, const int _Align);
__n128 __vld1q_s64_ex(_In_reads_(2) const int64_t * _PcD, const int _Align);
__n128 __vld1q_s8_ex(_In_reads_(16) const int8_t * _PcD, const int _Align);
__n128 __vld1q_u16_ex(_In_reads_(8) const uint16_t * _PcD, const int _Align);
__n128 __vld1q_u32_ex(_In_reads_(4) const uint32_t * _PcD, const int _Align);
__n128 __vld1q_u64_ex(_In_reads_(2) const uint64_t * _PcD, const int _Align);
__n128 __vld1q_u8_ex(_In_reads_(16) const uint8_t * _PcD, const int _Align);
__n64 __vld1_dup_f32(_In_reads_(1) const float32_t * _PcD);
__n64 __vld1_dup_p16(_In_reads_(1) const poly16_t * _PcD);
__n64 __vld1_dup_p8(_In_reads_(1) const poly8_t * _PcD);
__n64 __vld1_dup_s16(_In_reads_(1) const int16_t * _PcD);
__n64 __vld1_dup_s32(_In_reads_(1) const int32_t * _PcD);
__n64 __vld1_dup_s8(_In_reads_(1) const int8_t * _PcD);
__n64 __vld1_dup_u16(_In_reads_(1) const uint16_t * _PcD);
__n64 __vld1_dup_u32(_In_reads_(1) const uint32_t * _PcD);
__n64 __vld1_dup_u8(_In_reads_(1) const uint8_t * _PcD);
__n128 __vld1q_dup_f32(_In_reads_(1) const float32_t * _PcD);
__n128 __vld1q_dup_p16(_In_reads_(1) const poly16_t * _PcD);
__n128 __vld1q_dup_p8(_In_reads_(1) const poly8_t * _PcD);
__n128 __vld1q_dup_s16(_In_reads_(1) const int16_t * _PcD);
__n128 __vld1q_dup_s32(_In_reads_(1) const int32_t * _PcD);
__n128 __vld1q_dup_s8(_In_reads_(1) const int8_t * _PcD);
__n128 __vld1q_dup_u16(_In_reads_(1) const uint16_t * _PcD);
__n128 __vld1q_dup_u32(_In_reads_(1) const uint32_t * _PcD);
__n128 __vld1q_dup_u8(_In_reads_(1) const uint8_t * _PcD);
__n64 __vld1_dup_f32_ex(_In_reads_(1) const float32_t * _PcD, const int _Align);
__n64 __vld1_dup_p16_ex(_In_reads_(1) const poly16_t * _PcD, const int _Align);
__n64 __vld1_dup_s16_ex(_In_reads_(1) const int16_t * _PcD, const int _Align);
__n64 __vld1_dup_s32_ex(_In_reads_(1) const int32_t * _PcD, const int _Align);
__n64 __vld1_dup_u16_ex(_In_reads_(1) const uint16_t * _PcD, const int _Align);
__n64 __vld1_dup_u32_ex(_In_reads_(1) const uint32_t * _PcD, const int _Align);
__n128 __vld1q_dup_f32_ex(_In_reads_(1) const float32_t * _PcD, const int _Align);
__n128 __vld1q_dup_p16_ex(_In_reads_(1) const poly16_t * _PcD, const int _Align);
__n128 __vld1q_dup_s16_ex(_In_reads_(1) const int16_t * _PcD, const int _Align);
__n128 __vld1q_dup_s32_ex(_In_reads_(1) const int32_t * _PcD, const int _Align);
__n128 __vld1q_dup_u16_ex(_In_reads_(1) const uint16_t * _PcD, const int _Align);
__n128 __vld1q_dup_u32_ex(_In_reads_(1) const uint32_t * _PcD, const int _Align);
__n64 __vld1_lane_f32(_In_reads_(1) const float32_t * _PcD, __n64 _Dd, const int _Lane);
__n64 __vld1_lane_p16(_In_reads_(1) const poly16_t * _PcD, __n64 _Dd, const int _Lane);
__n64 __vld1_lane_p8(_In_reads_(1) const poly8_t * _PcD, __n64 _Dd, const int _Lane);
__n64 __vld1_lane_s16(_In_reads_(1) const int16_t * _PcD, __n64 _Dd, const int _Lane);
__n64 __vld1_lane_s32(_In_reads_(1) const int32_t * _PcD, __n64 _Dd, const int _Lane);
__n64 __vld1_lane_s8(_In_reads_(1) const int8_t * _PcD, __n64 _Dd, const int _Lane);
__n64 __vld1_lane_u16(_In_reads_(1) const uint16_t * _PcD, __n64 _Dd, const int _Lane);
__n64 __vld1_lane_u32(_In_reads_(1) const uint32_t * _PcD, __n64 _Dd, const int _Lane);
__n64 __vld1_lane_u8(_In_reads_(1) const uint8_t * _PcD, __n64 _Dd, const int _Lane);
__n128 __vld1q_lane_f32(_In_reads_(1) const float32_t * _PcD, __n128 _Qd, const int _Lane);
__n128 __vld1q_lane_p16(_In_reads_(1) const poly16_t * _PcD, __n128 _Qd, const int _Lane);
__n128 __vld1q_lane_p8(_In_reads_(1) const poly8_t * _PcD, __n128 _Qd, const int _Lane);
__n128 __vld1q_lane_s16(_In_reads_(1) const int16_t * _PcD, __n128 _Qd, const int _Lane);
__n128 __vld1q_lane_s32(_In_reads_(1) const int32_t * _PcD, __n128 _Qd, const int _Lane);
__n128 __vld1q_lane_s8(_In_reads_(1) const int8_t * _PcD, __n128 _Qd, const int _Lane);
__n128 __vld1q_lane_u16(_In_reads_(1) const uint16_t * _PcD, __n128 _Qd, const int _Lane);
__n128 __vld1q_lane_u32(_In_reads_(1) const uint32_t * _PcD, __n128 _Qd, const int _Lane);
__n128 __vld1q_lane_u8(_In_reads_(1) const uint8_t * _PcD, __n128 _Qd, const int _Lane);
__n64 __vld1_lane_f32_ex(_In_reads_(1) const float32_t * _PcD, __n64 _Dd, const int _Lane, const int _Align);
__n64 __vld1_lane_p16_ex(_In_reads_(1) const poly16_t * _PcD, __n64 _Dd, const int _Lane, const int _Align);
__n64 __vld1_lane_s16_ex(_In_reads_(1) const int16_t * _PcD, __n64 _Dd, const int _Lane, const int _Align);
__n64 __vld1_lane_s32_ex(_In_reads_(1) const int32_t * _PcD, __n64 _Dd, const int _Lane, const int _Align);
__n64 __vld1_lane_u16_ex(_In_reads_(1) const uint16_t * _PcD, __n64 _Dd, const int _Lane, const int _Align);
__n64 __vld1_lane_u32_ex(_In_reads_(1) const uint32_t * _PcD, __n64 _Dd, const int _Lane, const int _Align);
__n128 __vld1q_lane_f32_ex(_In_reads_(1) const float32_t * _PcD, __n128 _Qd, const int _Lane, const int _Align);
__n128 __vld1q_lane_p16_ex(_In_reads_(1) const poly16_t * _PcD, __n128 _Qd, const int _Lane, const int _Align);
__n128 __vld1q_lane_s16_ex(_In_reads_(1) const int16_t * _PcD, __n128 _Qd, const int _Lane, const int _Align);
__n128 __vld1q_lane_s32_ex(_In_reads_(1) const int32_t * _PcD, __n128 _Qd, const int _Lane, const int _Align);
__n128 __vld1q_lane_u16_ex(_In_reads_(1) const uint16_t * _PcD, __n128 _Qd, const int _Lane, const int _Align);
__n128 __vld1q_lane_u32_ex(_In_reads_(1) const uint32_t * _PcD, __n128 _Qd, const int _Lane, const int _Align);
__n64x2 __vld2_f32(_In_reads_(4) const float32_t * _PcD);
__n64x2 __vld2_p16(_In_reads_(8) const poly16_t * _PcD);
__n64x2 __vld2_p8(_In_reads_(16) const poly8_t * _PcD);
__n64x2 __vld2_s16(_In_reads_(8) const int16_t * _PcD);
__n64x2 __vld2_s32(_In_reads_(4) const int32_t * _PcD);
__n64x2 __vld2_s8(_In_reads_(16) const int8_t * _PcD);
__n64x2 __vld2_u16(_In_reads_(8) const uint16_t * _PcD);
__n64x2 __vld2_u32(_In_reads_(4) const uint32_t * _PcD);
__n64x2 __vld2_u8(_In_reads_(16) const uint8_t * _PcD);
__n64x2 __vld2_s64(_In_reads_(2) const int64_t * _PcD);
__n64x2 __vld2_u64(_In_reads_(2) const uint64_t * _PcD);
__n64x2 __vld2_s64_ex(_In_reads_(2) const int64_t * _PcD, const int _Align);
__n64x2 __vld2_u64_ex(_In_reads_(2) const uint64_t * _PcD, const int _Align);
__n64x2 __vld2_f32_ex(_In_reads_(4) const float32_t * _PcD, const int _Align);
__n64x2 __vld2_p16_ex(_In_reads_(8) const poly16_t * _PcD, const int _Align);
__n64x2 __vld2_p8_ex(_In_reads_(16) const poly8_t * _PcD, const int _Align);
__n64x2 __vld2_s16_ex(_In_reads_(8) const int16_t * _PcD, const int _Align);
__n64x2 __vld2_s32_ex(_In_reads_(4) const int32_t * _PcD, const int _Align);
__n64x2 __vld2_s8_ex(_In_reads_(16) const int8_t * _PcD, const int _Align);
__n64x2 __vld2_u16_ex(_In_reads_(8) const uint16_t * _PcD, const int _Align);
__n64x2 __vld2_u32_ex(_In_reads_(4) const uint32_t * _PcD, const int _Align);
__n64x2 __vld2_u8_ex(_In_reads_(16) const uint8_t * _PcD, const int _Align);
__n128x2 __vld2q_f32(_In_reads_(8) const float32_t * _PcD);
__n128x2 __vld2q_p16(_In_reads_(16) const poly16_t * _PcD);
__n128x2 __vld2q_p8(_In_reads_(32) const poly8_t * _PcD);
__n128x2 __vld2q_s16(_In_reads_(16) const int16_t * _PcD);
__n128x2 __vld2q_s32(_In_reads_(8) const int32_t * _PcD);
__n128x2 __vld2q_s8(_In_reads_(32) const int8_t * _PcD);
__n128x2 __vld2q_u16(_In_reads_(16) const uint16_t * _PcD);
__n128x2 __vld2q_u32(_In_reads_(8) const uint32_t * _PcD);
__n128x2 __vld2q_u8(_In_reads_(32) const uint8_t * _PcD);
__n128x2 __vld2q_f32_ex(_In_reads_(8) const float32_t * _PcD, const int _Align);
__n128x2 __vld2q_p16_ex(_In_reads_(16) const poly16_t * _PcD, const int _Align);
__n128x2 __vld2q_p8_ex(_In_reads_(32) const poly8_t * _PcD, const int _Align);
__n128x2 __vld2q_s16_ex(_In_reads_(16) const int16_t * _PcD, const int _Align);
__n128x2 __vld2q_s32_ex(_In_reads_(8) const int32_t * _PcD, const int _Align);
__n128x2 __vld2q_s8_ex(_In_reads_(32) const int8_t * _PcD, const int _Align);
__n128x2 __vld2q_u16_ex(_In_reads_(16) const uint16_t * _PcD, const int _Align);
__n128x2 __vld2q_u32_ex(_In_reads_(8) const uint32_t * _PcD, const int _Align);
__n128x2 __vld2q_u8_ex(_In_reads_(32) const uint8_t * _PcD, const int _Align);
__n64x2 __vld2_dup_f32(_In_reads_(2) const float32_t * _PcD);
__n64x2 __vld2_dup_p16(_In_reads_(2) const poly16_t * _PcD);
__n64x2 __vld2_dup_p8(_In_reads_(2) const poly8_t * _PcD);
__n64x2 __vld2_dup_s16(_In_reads_(2) const int16_t * _PcD);
__n64x2 __vld2_dup_s32(_In_reads_(2) const int32_t * _PcD);
__n64x2 __vld2_dup_s8(_In_reads_(2) const int8_t * _PcD);
__n64x2 __vld2_dup_u16(_In_reads_(2) const uint16_t * _PcD);
__n64x2 __vld2_dup_u32(_In_reads_(2) const uint32_t * _PcD);
__n64x2 __vld2_dup_u8(_In_reads_(2) const uint8_t * _PcD);
__n64x2 __vld2_dup_s64(_In_reads_(2) const int64_t * _PcD);
__n64x2 __vld2_dup_u64(_In_reads_(2) const uint64_t * _PcD);
__n64x2 __vld2_dup_s64_ex(_In_reads_(2) const int64_t * _PcD, const int _Align);
__n64x2 __vld2_dup_u64_ex(_In_reads_(2) const uint64_t * _PcD, const int _Align);
__n64x2 __vld2_dup_f32_ex(_In_reads_(2) const float32_t * _PcD, const int _Align);
__n64x2 __vld2_dup_p16_ex(_In_reads_(2) const poly16_t * _PcD, const int _Align);
__n64x2 __vld2_dup_p8_ex(_In_reads_(2) const poly8_t * _PcD, const int _Align);
__n64x2 __vld2_dup_s16_ex(_In_reads_(2) const int16_t * _PcD, const int _Align);
__n64x2 __vld2_dup_s32_ex(_In_reads_(2) const int32_t * _PcD, const int _Align);
__n64x2 __vld2_dup_s8_ex(_In_reads_(2) const int8_t * _PcD, const int _Align);
__n64x2 __vld2_dup_u16_ex(_In_reads_(2) const uint16_t * _PcD, const int _Align);
__n64x2 __vld2_dup_u32_ex(_In_reads_(2) const uint32_t * _PcD, const int _Align);
__n64x2 __vld2_dup_u8_ex(_In_reads_(2) const uint8_t * _PcD, const int _Align);
__n64x2 __vld2_lane_f32(_In_reads_(2) const float32_t * _PcD, __n64x2 _D2, const int _Lane);
__n64x2 __vld2_lane_p16(_In_reads_(2) const poly16_t * _PcD, __n64x2 _D2, const int _Lane);
__n64x2 __vld2_lane_p8(_In_reads_(2) const poly8_t * _PcD, __n64x2 _D2, const int _Lane);
__n64x2 __vld2_lane_s16(_In_reads_(2) const int16_t * _PcD, __n64x2 _D2, const int _Lane);
__n64x2 __vld2_lane_s32(_In_reads_(2) const int32_t * _PcD, __n64x2 _D2, const int _Lane);
__n64x2 __vld2_lane_s8(_In_reads_(2) const int8_t * _PcD, __n64x2 _D2, const int _Lane);
__n64x2 __vld2_lane_u16(_In_reads_(2) const uint16_t * _PcD, __n64x2 _D2, const int _Lane);
__n64x2 __vld2_lane_u32(_In_reads_(2) const uint32_t * _PcD, __n64x2 _D2, const int _Lane);
__n64x2 __vld2_lane_u8(_In_reads_(2) const uint8_t * _PcD, __n64x2 _D2, const int _Lane);
__n128x2 __vld2q_lane_f32(_In_reads_(2) const float32_t * _PcD, __n128x2 _Q2, const int _Lane);
__n128x2 __vld2q_lane_p16(_In_reads_(2) const poly16_t * _PcD, __n128x2 _Q2, const int _Lane);
__n128x2 __vld2q_lane_s16(_In_reads_(2) const int16_t * _PcD, __n128x2 _Q2, const int _Lane);
__n128x2 __vld2q_lane_s32(_In_reads_(2) const int32_t * _PcD, __n128x2 _Q2, const int _Lane);
__n128x2 __vld2q_lane_u16(_In_reads_(2) const uint16_t * _PcD, __n128x2 _Q2, const int _Lane);
__n128x2 __vld2q_lane_u32(_In_reads_(2) const uint32_t * _PcD, __n128x2 _Q2, const int _Lane);
__n64x2 __vld2_lane_f32_ex(_In_reads_(2) const float32_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n64x2 __vld2_lane_p16_ex(_In_reads_(2) const poly16_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n64x2 __vld2_lane_p8_ex(_In_reads_(2) const poly8_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n64x2 __vld2_lane_s16_ex(_In_reads_(2) const int16_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n64x2 __vld2_lane_s32_ex(_In_reads_(2) const int32_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n64x2 __vld2_lane_s8_ex(_In_reads_(2) const int8_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n64x2 __vld2_lane_u16_ex(_In_reads_(2) const uint16_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n64x2 __vld2_lane_u32_ex(_In_reads_(2) const uint32_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n64x2 __vld2_lane_u8_ex(_In_reads_(2) const uint8_t * _PcD, __n64x2 _D2, const int _Lane, const int _Align);
__n128x2 __vld2q_lane_f32_ex(_In_reads_(2) const float32_t * _PcD, __n128x2 _Q2, const int _Lane, const int _Align);
__n128x2 __vld2q_lane_p16_ex(_In_reads_(2) const poly16_t * _PcD, __n128x2 _Q2, const int _Lane, const int _Align);
__n128x2 __vld2q_lane_s16_ex(_In_reads_(2) const int16_t * _PcD, __n128x2 _Q2, const int _Lane, const int _Align);
__n128x2 __vld2q_lane_s32_ex(_In_reads_(2) const int32_t * _PcD, __n128x2 _Q2, const int _Lane, const int _Align);
__n128x2 __vld2q_lane_u16_ex(_In_reads_(2) const uint16_t * _PcD, __n128x2 _Q2, const int _Lane, const int _Align);
__n128x2 __vld2q_lane_u32_ex(_In_reads_(2) const uint32_t * _PcD, __n128x2 _Q2, const int _Lane, const int _Align);
__n64x3 __vld3_f32(_In_reads_(6) const float32_t * _PcD);
__n64x3 __vld3_p16(_In_reads_(12) const poly16_t * _PcD);
__n64x3 __vld3_p8(_In_reads_(24) const poly8_t * _PcD);
__n64x3 __vld3_s16(_In_reads_(12) const int16_t * _PcD);
__n64x3 __vld3_s32(_In_reads_(6) const int32_t * _PcD);
__n64x3 __vld3_s8(_In_reads_(24) const int8_t * _PcD);
__n64x3 __vld3_u16(_In_reads_(12) const uint16_t * _PcD);
__n64x3 __vld3_u32(_In_reads_(6) const uint32_t * _PcD);
__n64x3 __vld3_u8(_In_reads_(24) const uint8_t * _PcD);
__n64x3 __vld3_s64(_In_reads_(3) const int64_t * _PcD);
__n64x3 __vld3_u64(_In_reads_(3) const uint64_t * _PcD);
__n64x3 __vld3_s64_ex(_In_reads_(3) const int64_t * _PcD, const int _Align);
__n64x3 __vld3_u64_ex(_In_reads_(3) const uint64_t * _PcD, const int _Align);
__n64x3 __vld3_f32_ex(_In_reads_(6) const float32_t * _PcD, const int _Align);
__n64x3 __vld3_p16_ex(_In_reads_(12) const poly16_t * _PcD, const int _Align);
__n64x3 __vld3_p8_ex(_In_reads_(24) const poly8_t * _PcD, const int _Align);
__n64x3 __vld3_s16_ex(_In_reads_(12) const int16_t * _PcD, const int _Align);
__n64x3 __vld3_s32_ex(_In_reads_(6) const int32_t * _PcD, const int _Align);
__n64x3 __vld3_s8_ex(_In_reads_(24) const int8_t * _PcD, const int _Align);
__n64x3 __vld3_u16_ex(_In_reads_(12) const uint16_t * _PcD, const int _Align);
__n64x3 __vld3_u32_ex(_In_reads_(6) const uint32_t * _PcD, const int _Align);
__n64x3 __vld3_u8_ex(_In_reads_(24) const uint8_t * _PcD, const int _Align);
__n128x3 __vld3q_f32(_In_reads_(12) const float32_t * _PcD);
__n128x3 __vld3q_p16(_In_reads_(24) const poly16_t * _PcD);
__n128x3 __vld3q_p8(_In_reads_(48) const poly8_t * _PcD);
__n128x3 __vld3q_s16(_In_reads_(24) const int16_t * _PcD);
__n128x3 __vld3q_s32(_In_reads_(12) const int32_t * _PcD);
__n128x3 __vld3q_s8(_In_reads_(48) const int8_t * _PcD);
__n128x3 __vld3q_u16(_In_reads_(24) const uint16_t * _PcD);
__n128x3 __vld3q_u32(_In_reads_(12) const uint32_t * _PcD);
__n128x3 __vld3q_u8(_In_reads_(48) const uint8_t * _PcD);
__n128x3 __vld3q_f32_ex(_In_reads_(12) const float32_t * _PcD, const int _Align);
__n128x3 __vld3q_p16_ex(_In_reads_(24) const poly16_t * _PcD, const int _Align);
__n128x3 __vld3q_p8_ex(_In_reads_(48) const poly8_t * _PcD, const int _Align);
__n128x3 __vld3q_s16_ex(_In_reads_(24) const int16_t * _PcD, const int _Align);
__n128x3 __vld3q_s32_ex(_In_reads_(12) const int32_t * _PcD, const int _Align);
__n128x3 __vld3q_s8_ex(_In_reads_(48) const int8_t * _PcD, const int _Align);
__n128x3 __vld3q_u16_ex(_In_reads_(24) const uint16_t * _PcD, const int _Align);
__n128x3 __vld3q_u32_ex(_In_reads_(12) const uint32_t * _PcD, const int _Align);
__n128x3 __vld3q_u8_ex(_In_reads_(48) const uint8_t * _PcD, const int _Align);
__n64x3 __vld3_dup_f32(_In_reads_(3) const float32_t * _PcD);
__n64x3 __vld3_dup_p16(_In_reads_(3) const poly16_t * _PcD);
__n64x3 __vld3_dup_p8(_In_reads_(3) const poly8_t * _PcD);
__n64x3 __vld3_dup_s16(_In_reads_(3) const int16_t * _PcD);
__n64x3 __vld3_dup_s32(_In_reads_(3) const int32_t * _PcD);
__n64x3 __vld3_dup_s8(_In_reads_(3) const int8_t * _PcD);
__n64x3 __vld3_dup_u16(_In_reads_(3) const uint16_t * _PcD);
__n64x3 __vld3_dup_u32(_In_reads_(3) const uint32_t * _PcD);
__n64x3 __vld3_dup_u8(_In_reads_(3) const uint8_t * _PcD);
__n64x3 __vld3_dup_s64(_In_reads_(3) const int64_t * _PcD);
__n64x3 __vld3_dup_u64(_In_reads_(3) const uint64_t * _PcD);
__n64x3 __vld3_lane_f32(_In_reads_(3) const float32_t * _PcD, __n64x3 _D3, const int _Lane);
__n64x3 __vld3_lane_p16(_In_reads_(3) const poly16_t * _PcD, __n64x3 _D3, const int _Lane);
__n64x3 __vld3_lane_p8(_In_reads_(3) const poly8_t * _PcD, __n64x3 _D3, const int _Lane);
__n64x3 __vld3_lane_s16(_In_reads_(3) const int16_t * _PcD, __n64x3 _D3, const int _Lane);
__n64x3 __vld3_lane_s32(_In_reads_(3) const int32_t * _PcD, __n64x3 _D3, const int _Lane);
__n64x3 __vld3_lane_s8(_In_reads_(3) const int8_t * _PcD, __n64x3 _D3, const int _Lane);
__n64x3 __vld3_lane_u16(_In_reads_(3) const uint16_t * _PcD, __n64x3 _D3, const int _Lane);
__n64x3 __vld3_lane_u32(_In_reads_(3) const uint32_t * _PcD, __n64x3 _D3, const int _Lane);
__n64x3 __vld3_lane_u8(_In_reads_(3) const uint8_t * _PcD, __n64x3 _D3, const int _Lane);
__n128x3 __vld3q_lane_f32(_In_reads_(3) const float32_t * _PcD, __n128x3 _Q3, const int _Lane);
__n128x3 __vld3q_lane_p16(_In_reads_(3) const poly16_t * _PcD, __n128x3 _Q3, const int _Lane);
__n128x3 __vld3q_lane_s16(_In_reads_(3) const int16_t * _PcD, __n128x3 _Q3, const int _Lane);
__n128x3 __vld3q_lane_s32(_In_reads_(3) const int32_t * _PcD, __n128x3 _Q3, const int _Lane);
__n128x3 __vld3q_lane_u16(_In_reads_(3) const uint16_t * _PcD, __n128x3 _Q3, const int _Lane);
__n128x3 __vld3q_lane_u32(_In_reads_(3) const uint32_t * _PcD, __n128x3 _Q3, const int _Lane);
__n64x4 __vld4_f32(_In_reads_(8) const float32_t * _PcD);
__n64x4 __vld4_p16(_In_reads_(16) const poly16_t * _PcD);
__n64x4 __vld4_p8(_In_reads_(32) const poly8_t * _PcD);
__n64x4 __vld4_s16(_In_reads_(16) const int16_t * _PcD);
__n64x4 __vld4_s32(_In_reads_(8) const int32_t * _PcD);
__n64x4 __vld4_s8(_In_reads_(32) const int8_t * _PcD);
__n64x4 __vld4_u16(_In_reads_(16) const uint16_t * _PcD);
__n64x4 __vld4_u32(_In_reads_(8) const uint32_t * _PcD);
__n64x4 __vld4_u8(_In_reads_(32) const uint8_t * _PcD);
__n64x4 __vld4_s64(_In_reads_(4) const int64_t * _PcD);
__n64x4 __vld4_u64(_In_reads_(4) const uint64_t * _PcD);
__n64x4 __vld4_s64_ex(_In_reads_(4) const int64_t * _PcD, const int _Align);
__n64x4 __vld4_u64_ex(_In_reads_(4) const uint64_t * _PcD, const int _Align);
__n64x4 __vld4_f32_ex(_In_reads_(8) const float32_t * _PcD, const int _Align);
__n64x4 __vld4_p16_ex(_In_reads_(16) const poly16_t * _PcD, const int _Align);
__n64x4 __vld4_p8_ex(_In_reads_(32) const poly8_t * _PcD, const int _Align);
__n64x4 __vld4_s16_ex(_In_reads_(16) const int16_t * _PcD, const int _Align);
__n64x4 __vld4_s32_ex(_In_reads_(8) const int32_t * _PcD, const int _Align);
__n64x4 __vld4_s8_ex(_In_reads_(32) const int8_t * _PcD, const int _Align);
__n64x4 __vld4_u16_ex(_In_reads_(16) const uint16_t * _PcD, const int _Align);
__n64x4 __vld4_u32_ex(_In_reads_(8) const uint32_t * _PcD, const int _Align);
__n64x4 __vld4_u8_ex(_In_reads_(32) const uint8_t * _PcD, const int _Align);
__n128x4 __vld4q_f32(_In_reads_(16) const float32_t * _PcD);
__n128x4 __vld4q_p16(_In_reads_(32) const poly16_t * _PcD);
__n128x4 __vld4q_p8(_In_reads_(64) const poly8_t * _PcD);
__n128x4 __vld4q_s16(_In_reads_(32) const int16_t * _PcD);
__n128x4 __vld4q_s32(_In_reads_(16) const int32_t * _PcD);
__n128x4 __vld4q_s8(_In_reads_(64) const int8_t * _PcD);
__n128x4 __vld4q_u16(_In_reads_(32) const uint16_t * _PcD);
__n128x4 __vld4q_u32(_In_reads_(16) const uint32_t * _PcD);
__n128x4 __vld4q_u8(_In_reads_(64) const uint8_t * _PcD);
__n128x4 __vld4q_f32_ex(_In_reads_(16) const float32_t * _PcD, const int _Align);
__n128x4 __vld4q_p16_ex(_In_reads_(32) const poly16_t * _PcD, const int _Align);
__n128x4 __vld4q_p8_ex(_In_reads_(64) const poly8_t * _PcD, const int _Align);
__n128x4 __vld4q_s16_ex(_In_reads_(32) const int16_t * _PcD, const int _Align);
__n128x4 __vld4q_s32_ex(_In_reads_(16) const int32_t * _PcD, const int _Align);
__n128x4 __vld4q_s8_ex(_In_reads_(64) const int8_t * _PcD, const int _Align);
__n128x4 __vld4q_u16_ex(_In_reads_(32) const uint16_t * _PcD, const int _Align);
__n128x4 __vld4q_u32_ex(_In_reads_(16) const uint32_t * _PcD, const int _Align);
__n128x4 __vld4q_u8_ex(_In_reads_(64) const uint8_t * _PcD, const int _Align);
__n64x4 __vld4_dup_f32(_In_reads_(4) const float32_t * _PcD);
__n64x4 __vld4_dup_p16(_In_reads_(4) const poly16_t * _PcD);
__n64x4 __vld4_dup_p8(_In_reads_(4) const poly8_t * _PcD);
__n64x4 __vld4_dup_s16(_In_reads_(4) const int16_t * _PcD);
__n64x4 __vld4_dup_s32(_In_reads_(4) const int32_t * _PcD);
__n64x4 __vld4_dup_s8(_In_reads_(4) const int8_t * _PcD);
__n64x4 __vld4_dup_u16(_In_reads_(4) const uint16_t * _PcD);
__n64x4 __vld4_dup_u32(_In_reads_(4) const uint32_t * _PcD);
__n64x4 __vld4_dup_u8(_In_reads_(4) const uint8_t * _PcD);
__n64x4 __vld4_dup_s64(_In_reads_(4) const int64_t * _PcD);
__n64x4 __vld4_dup_u64(_In_reads_(4) const uint64_t * _PcD);
__n64x4 __vld4_dup_f32_ex(_In_reads_(4) const float32_t * _PcD, const int _Align);
__n64x4 __vld4_dup_p16_ex(_In_reads_(4) const poly16_t * _PcD, const int _Align);
__n64x4 __vld4_dup_p8_ex(_In_reads_(4) const poly8_t * _PcD, const int _Align);
__n64x4 __vld4_dup_s16_ex(_In_reads_(4) const int16_t * _PcD, const int _Align);
__n64x4 __vld4_dup_s32_ex(_In_reads_(4) const int32_t * _PcD, const int _Align);
__n64x4 __vld4_dup_s8_ex(_In_reads_(4) const int8_t * _PcD, const int _Align);
__n64x4 __vld4_dup_u16_ex(_In_reads_(4) const uint16_t * _PcD, const int _Align);
__n64x4 __vld4_dup_u32_ex(_In_reads_(4) const uint32_t * _PcD, const int _Align);
__n64x4 __vld4_dup_u8_ex(_In_reads_(4) const uint8_t * _PcD, const int _Align);
__n64x4 __vld4_lane_f32(_In_reads_(4) const float32_t * _PcD, __n64x4 _D4, const int _Lane);
__n64x4 __vld4_lane_p16(_In_reads_(4) const poly16_t * _PcD, __n64x4 _D4, const int _Lane);
__n64x4 __vld4_lane_p8(_In_reads_(4) const poly8_t * _PcD, __n64x4 _D4, const int _Lane);
__n64x4 __vld4_lane_s16(_In_reads_(4) const int16_t * _PcD, __n64x4 _D4, const int _Lane);
__n64x4 __vld4_lane_s32(_In_reads_(4) const int32_t * _PcD, __n64x4 _D4, const int _Lane);
__n64x4 __vld4_lane_s8(_In_reads_(4) const int8_t * _PcD, __n64x4 _D4, const int _Lane);
__n64x4 __vld4_lane_u16(_In_reads_(4) const uint16_t * _PcD, __n64x4 _D4, const int _Lane);
__n64x4 __vld4_lane_u32(_In_reads_(4) const uint32_t * _PcD, __n64x4 _D4, const int _Lane);
__n64x4 __vld4_lane_u8(_In_reads_(4) const uint8_t * _PcD, __n64x4 _D4, const int _Lane);
__n128x4 __vld4q_lane_f32(_In_reads_(4) const float32_t * _PcD, __n128x4 _Q4, const int _Lane);
__n128x4 __vld4q_lane_p16(_In_reads_(4) const poly16_t * _PcD, __n128x4 _Q4, const int _Lane);
__n128x4 __vld4q_lane_s16(_In_reads_(4) const int16_t * _PcD, __n128x4 _Q4, const int _Lane);
__n128x4 __vld4q_lane_s32(_In_reads_(4) const int32_t * _PcD, __n128x4 _Q4, const int _Lane);
__n128x4 __vld4q_lane_u16(_In_reads_(4) const uint16_t * _PcD, __n128x4 _Q4, const int _Lane);
__n128x4 __vld4q_lane_u32(_In_reads_(4) const uint32_t * _PcD, __n128x4 _Q4, const int _Lane);
__n64x4 __vld4_lane_f32_ex(_In_reads_(4) const float32_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n64x4 __vld4_lane_p16_ex(_In_reads_(4) const poly16_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n64x4 __vld4_lane_p8_ex(_In_reads_(4) const poly8_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n64x4 __vld4_lane_s16_ex(_In_reads_(4) const int16_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n64x4 __vld4_lane_s32_ex(_In_reads_(4) const int32_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n64x4 __vld4_lane_s8_ex(_In_reads_(4) const int8_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n64x4 __vld4_lane_u16_ex(_In_reads_(4) const uint16_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n64x4 __vld4_lane_u32_ex(_In_reads_(4) const uint32_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n64x4 __vld4_lane_u8_ex(_In_reads_(4) const uint8_t * _PcD, __n64x4 _D4, const int _Lane, const int _Align);
__n128x4 __vld4q_lane_f32_ex(_In_reads_(4) const float32_t * _PcD, __n128x4 _Q4, const int _Lane, const int _Align);
__n128x4 __vld4q_lane_p16_ex(_In_reads_(4) const poly16_t * _PcD, __n128x4 _Q4, const int _Lane, const int _Align);
__n128x4 __vld4q_lane_s16_ex(_In_reads_(4) const int16_t * _PcD, __n128x4 _Q4, const int _Lane, const int _Align);
__n128x4 __vld4q_lane_s32_ex(_In_reads_(4) const int32_t * _PcD, __n128x4 _Q4, const int _Lane, const int _Align);
__n128x4 __vld4q_lane_u16_ex(_In_reads_(4) const uint16_t * _PcD, __n128x4 _Q4, const int _Lane, const int _Align);
__n128x4 __vld4q_lane_u32_ex(_In_reads_(4) const uint32_t * _PcD, __n128x4 _Q4, const int _Lane, const int _Align);
__n64 __vmax_f32(__n64 _Dn, __n64 _Dm);
__n64 __vmaxnm_f32(__n64 _Dn, __n64 _Dm);
__n64 __vmin_f32(__n64 _Dn, __n64 _Dm);
__n64 __vminnm_f32(__n64 _Dn, __n64 _Dm);
__n128 __vmaxq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vmaxnmq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vminq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vminnmq_f32(__n128 _Qn, __n128 _Qm);
__n64 __vmax_s16(__n64 _Dn, __n64 _Dm);
__n64 __vmax_s32(__n64 _Dn, __n64 _Dm);
__n64 __vmax_s8(__n64 _Dn, __n64 _Dm);
__n64 __vmax_u16(__n64 _Dn, __n64 _Dm);
__n64 __vmax_u32(__n64 _Dn, __n64 _Dm);
__n64 __vmax_u8(__n64 _Dn, __n64 _Dm);
__n64 __vmin_s16(__n64 _Dn, __n64 _Dm);
__n64 __vmin_s32(__n64 _Dn, __n64 _Dm);
__n64 __vmin_s8(__n64 _Dn, __n64 _Dm);
__n64 __vmin_u16(__n64 _Dn, __n64 _Dm);
__n64 __vmin_u32(__n64 _Dn, __n64 _Dm);
__n64 __vmin_u8(__n64 _Dn, __n64 _Dm);
__n128 __vmaxq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vmaxq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vmaxq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vmaxq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vmaxq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vmaxq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vminq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vminq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vminq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vminq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vminq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vminq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vmla_lane_f32(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmla_lane_s16(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmla_lane_s32(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmla_lane_u16(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmla_lane_u32(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmls_lane_f32(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmls_lane_s16(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmls_lane_s32(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmls_lane_u16(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmls_lane_u32(__n64 _Dd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmlaq_lane_f32(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlaq_lane_s16(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlaq_lane_s32(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlaq_lane_u16(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlaq_lane_u32(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlsq_lane_f32(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlsq_lane_s16(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlsq_lane_s32(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlsq_lane_u16(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmlsq_lane_u32(__n128 _Qd, __n128 _Qn, __n64 _Dm, const int _Lane);
__n64 __vmla_n_f32(__n64 _Dd, __n64 _Dn, float32_t _Ft);
__n64 __vmls_n_f32(__n64 _Dd, __n64 _Dn, float32_t _Ft);
__n128 __vmlaq_n_f32(__n128 _Qd, __n128 _Qn, float32_t _Ft);
__n128 __vmlsq_n_f32(__n128 _Qd, __n128 _Qn, float32_t _Ft);
__n64 __vmla_f32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmls_f32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n128 __vmlaq_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlsq_f32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n64 __vmla_s16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmla_s32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmla_s8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmla_u16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmla_u32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmla_u8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmls_s16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmls_s32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmls_s8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmls_u16(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmls_u32(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vmls_u8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n128 __vmlaq_s16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlaq_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlaq_s8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlaq_u16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlaq_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlaq_u8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlsq_s16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlsq_s32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlsq_s8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlsq_u16(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlsq_u32(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlsq_u8(__n128 _Qd, __n128 _Qn, __n128 _Qm);
__n128 __vmlal_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlal_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlal_s8(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlal_u16(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlal_u32(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlal_u8(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlsl_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlsl_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlsl_s8(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlsl_u16(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlsl_u32(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlsl_u8(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vmlal_lane_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmlal_lane_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmlal_lane_u16(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmlal_lane_u32(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmlsl_lane_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmlsl_lane_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmlsl_lane_u16(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmlsl_lane_u32(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vset_lane_f32(float32_t _Ft, __n64 _Dd, const int _Lane);
__n64 __vset_lane_p16(poly16_t _Rt, __n64 _Dd, const int _Lane);
__n64 __vset_lane_p8(poly8_t _Rt, __n64 _Dd, const int _Lane);
__n64 __vset_lane_s16(int16_t _Rt, __n64 _Dd, const int _Lane);
__n64 __vset_lane_s32(int32_t _Rt, __n64 _Dd, const int _Lane);
__n64 __vset_lane_s8(int8_t _Rt, __n64 _Dd, const int _Lane);
__n64 __vset_lane_u16(uint16_t _Rt, __n64 _Dd, const int _Lane);
__n64 __vset_lane_u32(uint32_t _Rt, __n64 _Dd, const int _Lane);
__n64 __vset_lane_u8(uint8_t _Rt, __n64 _Dd, const int _Lane);
float32_t __vget_lane_f32(__n64 _Dm, const int _Lane);
poly16_t __vget_lane_p16(__n64 _Dm, const int _Lane);
poly8_t __vget_lane_p8(__n64 _Dm, const int _Lane);
int16_t __vget_lane_s16(__n64 _Dm, const int _Lane);
int8_t __vget_lane_s8(__n64 _Dm, const int _Lane);
int32_t __vget_lane_s32(__n64 _Dm, const int _Lane);
uint16_t __vget_lane_u16(__n64 _Dm, const int _Lane);
uint8_t __vget_lane_u8(__n64 _Dm, const int _Lane);
uint32_t __vget_lane_u32(__n64 _Dm, const int _Lane);
__n64 __vset_lane_s64(int64_t _R64t, __n64 _Dd, const int _Lane);
__n64 __vset_lane_u64(uint64_t _R64t, __n64 _Dd, const int _Lane);
__n128 __vsetq_lane_s64(int64_t _R64t, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_u64(uint64_t _R64t, __n128 _Qd, const int _Lane);
int64_t __vget_lane_s64(__n64 _Dm, const int _Lane);
uint64_t __vget_lane_u64(__n64 _Dm, const int _Lane);
int64_t __vgetq_lane_s64(__n128 _Qm, const int _Lane);
uint64_t __vgetq_lane_u64(__n128 _Qm, const int _Lane);
__n128 __vsetq_lane_f32(float32_t _Ft, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_p16(poly16_t _Rt, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_p8(poly8_t _Rt, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_s16(int16_t _Rt, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_s32(int32_t _Rt, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_s8(int8_t _Rt, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_u16(uint16_t _Rt, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_u32(uint32_t _Rt, __n128 _Qd, const int _Lane);
__n128 __vsetq_lane_u8(uint8_t _Rt, __n128 _Qd, const int _Lane);
float32_t __vgetq_lane_f32(__n128 _Qm, const int _Lane);
poly16_t __vgetq_lane_p16(__n128 _Qm, const int _Lane);
poly8_t __vgetq_lane_p8(__n128 _Qm, const int _Lane);
int16_t __vgetq_lane_s16(__n128 _Qm, const int _Lane);
int8_t __vgetq_lane_s8(__n128 _Qm, const int _Lane);
int32_t __vgetq_lane_s32(__n128 _Qm, const int _Lane);
uint16_t __vgetq_lane_u16(__n128 _Qm, const int _Lane);
uint8_t __vgetq_lane_u8(__n128 _Qm, const int _Lane);
uint32_t __vgetq_lane_u32(__n128 _Qm, const int _Lane);
__n128 __vmovl_s16(__n64 _Dm);
__n128 __vmovl_s32(__n64 _Dm);
__n128 __vmovl_s8(__n64 _Dm);
__n128 __vmovl_u16(__n64 _Dm);
__n128 __vmovl_u32(__n64 _Dm);
__n128 __vmovl_u8(__n64 _Dm);
__n64 __vmovn_s16(__n128 _Qm);
__n64 __vmovn_s32(__n128 _Qm);
__n64 __vmovn_s64(__n128 _Qm);
__n64 __vmovn_u16(__n128 _Qm);
__n64 __vmovn_u32(__n128 _Qm);
__n64 __vmovn_u64(__n128 _Qm);
__n64 __vmul_f32(__n64 _Dn, __n64 _Dm);
__n64 __vmul_p8(__n64 _Dn, __n64 _Dm);
__n64 __vmul_s16(__n64 _Dn, __n64 _Dm);
__n64 __vmul_s32(__n64 _Dn, __n64 _Dm);
__n64 __vmul_s8(__n64 _Dn, __n64 _Dm);
__n64 __vmul_u16(__n64 _Dn, __n64 _Dm);
__n64 __vmul_u32(__n64 _Dn, __n64 _Dm);
__n64 __vmul_u8(__n64 _Dn, __n64 _Dm);
__n128 __vmulq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vmulq_p8(__n128 _Qn, __n128 _Qm);
__n128 __vmulq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vmulq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vmulq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vmulq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vmulq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vmulq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vmul_n_f32(__n64 _Dn, float32_t _Ft);
__n128 __vmulq_n_f32(__n128 _Qn, float32_t _Ft);
__n64 __vmul_lane_f32(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmul_lane_s16(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmul_lane_s32(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmul_lane_u16(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmul_lane_u32(__n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmulq_lane_f32(__n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmulq_lane_s16(__n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmulq_lane_s32(__n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmulq_lane_u16(__n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmulq_lane_u32(__n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vmull_p64(__n64 _Dn, __n64 _Dm);
__n128 __vmull_p8(__n64 _Dn, __n64 _Dm);
__n128 __vmull_s16(__n64 _Dn, __n64 _Dm);
__n128 __vmull_s32(__n64 _Dn, __n64 _Dm);
__n128 __vmull_s8(__n64 _Dn, __n64 _Dm);
__n128 __vmull_u16(__n64 _Dn, __n64 _Dm);
__n128 __vmull_u32(__n64 _Dn, __n64 _Dm);
__n128 __vmull_u8(__n64 _Dn, __n64 _Dm);
__n128 __vmull_lane_s16(__n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmull_lane_s32(__n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmull_lane_u16(__n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vmull_lane_u32(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vmvn_p16(__n64 _Dm);
__n64 __vmvn_p8(__n64 _Dm);
__n64 __vmvn_s16(__n64 _Dm);
__n64 __vmvn_s32(__n64 _Dm);
__n64 __vmvn_s8(__n64 _Dm);
__n64 __vmvn_u16(__n64 _Dm);
__n64 __vmvn_u32(__n64 _Dm);
__n64 __vmvn_u8(__n64 _Dm);
__n128 __vmvnq_p16(__n128 _Qm);
__n128 __vmvnq_p8(__n128 _Qm);
__n128 __vmvnq_s16(__n128 _Qm);
__n128 __vmvnq_s32(__n128 _Qm);
__n128 __vmvnq_s8(__n128 _Qm);
__n128 __vmvnq_u16(__n128 _Qm);
__n128 __vmvnq_u32(__n128 _Qm);
__n128 __vmvnq_u8(__n128 _Qm);
__n64 __vpadal_s16(__n64 _Dd, __n64 _Dm);
__n64 __vpadal_s32(__n64 _Dd, __n64 _Dm);
__n64 __vpadal_s8(__n64 _Dd, __n64 _Dm);
__n64 __vpadal_u16(__n64 _Dd, __n64 _Dm);
__n64 __vpadal_u32(__n64 _Dd, __n64 _Dm);
__n64 __vpadal_u8(__n64 _Dd, __n64 _Dm);
__n128 __vpadalq_s16(__n128 _Qd, __n128 _Qm);
__n128 __vpadalq_s32(__n128 _Qd, __n128 _Qm);
__n128 __vpadalq_s8(__n128 _Qd, __n128 _Qm);
__n128 __vpadalq_u16(__n128 _Qd, __n128 _Qm);
__n128 __vpadalq_u32(__n128 _Qd, __n128 _Qm);
__n128 __vpadalq_u8(__n128 _Qd, __n128 _Qm);
__n64 __vpadd_f32(__n64 _Dn, __n64 _Dm);
__n64 __vpadd_s16(__n64 _Dn, __n64 _Dm);
__n64 __vpadd_s32(__n64 _Dn, __n64 _Dm);
__n64 __vpadd_s8(__n64 _Dn, __n64 _Dm);
__n64 __vpadd_u16(__n64 _Dn, __n64 _Dm);
__n64 __vpadd_u32(__n64 _Dn, __n64 _Dm);
__n64 __vpadd_u8(__n64 _Dn, __n64 _Dm);
__n64 __vpaddl_s16(__n64 _Dm);
__n64 __vpaddl_s32(__n64 _Dm);
__n64 __vpaddl_s8(__n64 _Dm);
__n64 __vpaddl_u16(__n64 _Dm);
__n64 __vpaddl_u32(__n64 _Dm);
__n64 __vpaddl_u8(__n64 _Dm);
__n128 __vpaddlq_s16(__n128 _Qm);
__n128 __vpaddlq_s32(__n128 _Qm);
__n128 __vpaddlq_s8(__n128 _Qm);
__n128 __vpaddlq_u16(__n128 _Qm);
__n128 __vpaddlq_u32(__n128 _Qm);
__n128 __vpaddlq_u8(__n128 _Qm);
__n64 __vpmax_f32(__n64 _Dn, __n64 _Dm);
__n64 __vpmin_f32(__n64 _Dn, __n64 _Dm);
__n64 __vpmax_s16(__n64 _Dn, __n64 _Dm);
__n64 __vpmax_s32(__n64 _Dn, __n64 _Dm);
__n64 __vpmax_s8(__n64 _Dn, __n64 _Dm);
__n64 __vpmax_u16(__n64 _Dn, __n64 _Dm);
__n64 __vpmax_u32(__n64 _Dn, __n64 _Dm);
__n64 __vpmax_u8(__n64 _Dn, __n64 _Dm);
__n64 __vpmin_s16(__n64 _Dn, __n64 _Dm);
__n64 __vpmin_s32(__n64 _Dn, __n64 _Dm);
__n64 __vpmin_s8(__n64 _Dn, __n64 _Dm);
__n64 __vpmin_u16(__n64 _Dn, __n64 _Dm);
__n64 __vpmin_u32(__n64 _Dn, __n64 _Dm);
__n64 __vpmin_u8(__n64 _Dn, __n64 _Dm);
__n64 __vqabs_s16(__n64 _Dm);
__n64 __vqabs_s32(__n64 _Dm);
__n64 __vqabs_s8(__n64 _Dm);
__n64 __vqneg_s16(__n64 _Dm);
__n64 __vqneg_s32(__n64 _Dm);
__n64 __vqneg_s8(__n64 _Dm);
__n128 __vqabsq_s16(__n128 _Qm);
__n128 __vqabsq_s32(__n128 _Qm);
__n128 __vqabsq_s8(__n128 _Qm);
__n128 __vqnegq_s16(__n128 _Qm);
__n128 __vqnegq_s32(__n128 _Qm);
__n128 __vqnegq_s8(__n128 _Qm);
__n64 __vqadd_s16(__n64 _Dn, __n64 _Dm);
__n64 __vqadd_s32(__n64 _Dn, __n64 _Dm);
__n64 __vqadd_s64(__n64 _Dn, __n64 _Dm);
__n64 __vqadd_s8(__n64 _Dn, __n64 _Dm);
__n64 __vqadd_u16(__n64 _Dn, __n64 _Dm);
__n64 __vqadd_u32(__n64 _Dn, __n64 _Dm);
__n64 __vqadd_u64(__n64 _Dn, __n64 _Dm);
__n64 __vqadd_u8(__n64 _Dn, __n64 _Dm);
__n128 __vqaddq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vqaddq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vqaddq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vqaddq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vqaddq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vqaddq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vqaddq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vqaddq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vqdmlal_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vqdmlal_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vqdmlsl_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vqdmlsl_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm);
__n128 __vqdmlal_lane_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vqdmlal_lane_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vqdmlsl_lane_s16(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vqdmlsl_lane_s32(__n128 _Qd, __n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vqdmulh_lane_s16(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vqdmulh_lane_s32(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vqrdmulh_lane_s16(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vqrdmulh_lane_s32(__n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vqdmulhq_lane_s16(__n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vqdmulhq_lane_s32(__n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vqrdmulhq_lane_s16(__n128 _Qn, __n64 _Dm, const int _Lane);
__n128 __vqrdmulhq_lane_s32(__n128 _Qn, __n64 _Dm, const int _Lane);
__n64 __vqdmulh_s16(__n64 _Dn, __n64 _Dm);
__n64 __vqdmulh_s32(__n64 _Dn, __n64 _Dm);
__n64 __vqrdmulh_s16(__n64 _Dn, __n64 _Dm);
__n64 __vqrdmulh_s32(__n64 _Dn, __n64 _Dm);
__n128 __vqdmulhq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vqdmulhq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vqrdmulhq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vqrdmulhq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vqdmull_s16(__n64 _Dn, __n64 _Dm);
__n128 __vqdmull_s32(__n64 _Dn, __n64 _Dm);
__n128 __vqdmull_lane_s16(__n64 _Dn, __n64 _Dm, const int _Lane);
__n128 __vqdmull_lane_s32(__n64 _Dn, __n64 _Dm, const int _Lane);
__n64 __vqmovn_s16(__n128 _Qm);
__n64 __vqmovn_s32(__n128 _Qm);
__n64 __vqmovn_s64(__n128 _Qm);
__n64 __vqmovn_u16(__n128 _Qm);
__n64 __vqmovn_u32(__n128 _Qm);
__n64 __vqmovn_u64(__n128 _Qm);
__n64 __vqmovun_s16(__n128 _Qm);
__n64 __vqmovun_s32(__n128 _Qm);
__n64 __vqmovun_s64(__n128 _Qm);
__n64 __vqshl_n_s16(__n64 _Dm, const int _Shift_amount);
__n64 __vqshl_n_s32(__n64 _Dm, const int _Shift_amount);
__n64 __vqshl_n_s64(__n64 _Dm, const int _Shift_amount);
__n64 __vqshl_n_s8(__n64 _Dm, const int _Shift_amount);
__n64 __vqshl_n_u16(__n64 _Dm, const int _Shift_amount);
__n64 __vqshl_n_u32(__n64 _Dm, const int _Shift_amount);
__n64 __vqshl_n_u64(__n64 _Dm, const int _Shift_amount);
__n64 __vqshl_n_u8(__n64 _Dm, const int _Shift_amount);
__n64 __vqshlu_n_s16(__n64 _Dm, const int _Shift_amount);
__n64 __vqshlu_n_s32(__n64 _Dm, const int _Shift_amount);
__n64 __vqshlu_n_s64(__n64 _Dm, const int _Shift_amount);
__n64 __vqshlu_n_s8(__n64 _Dm, const int _Shift_amount);
__n128 __vqshlq_n_s16(__n128 _Qm, const int _Shift_amount);
__n128 __vqshlq_n_s32(__n128 _Qm, const int _Shift_amount);
__n128 __vqshlq_n_s64(__n128 _Qm, const int _Shift_amount);
__n128 __vqshlq_n_s8(__n128 _Qm, const int _Shift_amount);
__n128 __vqshlq_n_u16(__n128 _Qm, const int _Shift_amount);
__n128 __vqshlq_n_u32(__n128 _Qm, const int _Shift_amount);
__n128 __vqshlq_n_u64(__n128 _Qm, const int _Shift_amount);
__n128 __vqshlq_n_u8(__n128 _Qm, const int _Shift_amount);
__n128 __vqshluq_n_s16(__n128 _Qm, const int _Shift_amount);
__n128 __vqshluq_n_s32(__n128 _Qm, const int _Shift_amount);
__n128 __vqshluq_n_s64(__n128 _Qm, const int _Shift_amount);
__n128 __vqshluq_n_s8(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrn_n_s16(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrn_n_s32(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrn_n_s64(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrn_n_u16(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrn_n_u32(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrn_n_u64(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrun_n_s16(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrun_n_s32(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshrun_n_s64(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrn_n_s16(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrn_n_s32(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrn_n_s64(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrn_n_u16(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrn_n_u32(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrn_n_u64(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrun_n_s16(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrun_n_s32(__n128 _Qm, const int _Shift_amount);
__n64 __vqshrun_n_s64(__n128 _Qm, const int _Shift_amount);
__n64 __vqsub_s16(__n64 _Dn, __n64 _Dm);
__n64 __vqsub_s32(__n64 _Dn, __n64 _Dm);
__n64 __vqsub_s64(__n64 _Dn, __n64 _Dm);
__n64 __vqsub_s8(__n64 _Dn, __n64 _Dm);
__n64 __vqsub_u16(__n64 _Dn, __n64 _Dm);
__n64 __vqsub_u32(__n64 _Dn, __n64 _Dm);
__n64 __vqsub_u64(__n64 _Dn, __n64 _Dm);
__n64 __vqsub_u8(__n64 _Dn, __n64 _Dm);
__n128 __vqsubq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vqsubq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vqsubq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vqsubq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vqsubq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vqsubq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vqsubq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vqsubq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vrecpe_f32(__n64 _Dm);
__n64 __vrecpe_u32(__n64 _Dm);
__n64 __vrsqrte_f32(__n64 _Dm);
__n64 __vrsqrte_u32(__n64 _Dm);
__n128 __vrecpeq_f32(__n128 _Qm);
__n128 __vrecpeq_u32(__n128 _Qm);
__n128 __vrsqrteq_f32(__n128 _Qm);
__n128 __vrsqrteq_u32(__n128 _Qm);
__n64 __vrecps_f32(__n64 _Dn, __n64 _Dm);
__n128 __vrecpsq_f32(__n128 _Qn, __n128 _Qm);
__n64 __vrev16_p8(__n64 _Dm);
__n64 __vrev16_s8(__n64 _Dm);
__n64 __vrev16_u8(__n64 _Dm);
__n64 __vrev32_p16(__n64 _Dm);
__n64 __vrev32_p8(__n64 _Dm);
__n64 __vrev32_s16(__n64 _Dm);
__n64 __vrev32_s8(__n64 _Dm);
__n64 __vrev32_u16(__n64 _Dm);
__n64 __vrev32_u8(__n64 _Dm);
__n64 __vrev64_f32(__n64 _Dm);
__n64 __vrev64_p16(__n64 _Dm);
__n64 __vrev64_p8(__n64 _Dm);
__n64 __vrev64_s16(__n64 _Dm);
__n64 __vrev64_s32(__n64 _Dm);
__n64 __vrev64_s8(__n64 _Dm);
__n64 __vrev64_u16(__n64 _Dm);
__n64 __vrev64_u32(__n64 _Dm);
__n64 __vrev64_u8(__n64 _Dm);
__n128 __vrev16q_p8(__n128 _Qm);
__n128 __vrev16q_s8(__n128 _Qm);
__n128 __vrev16q_u8(__n128 _Qm);
__n128 __vrev32q_p16(__n128 _Qm);
__n128 __vrev32q_p8(__n128 _Qm);
__n128 __vrev32q_s16(__n128 _Qm);
__n128 __vrev32q_s8(__n128 _Qm);
__n128 __vrev32q_u16(__n128 _Qm);
__n128 __vrev32q_u8(__n128 _Qm);
__n128 __vrev64q_f32(__n128 _Qm);
__n128 __vrev64q_p16(__n128 _Qm);
__n128 __vrev64q_p8(__n128 _Qm);
__n128 __vrev64q_s16(__n128 _Qm);
__n128 __vrev64q_s32(__n128 _Qm);
__n128 __vrev64q_s8(__n128 _Qm);
__n128 __vrev64q_u16(__n128 _Qm);
__n128 __vrev64q_u32(__n128 _Qm);
__n128 __vrev64q_u8(__n128 _Qm);
__n64 __vrnd_f32(__n64 _Dm);
__n64 __vrnda_f32(__n64 _Dm);
__n64 __vrndm_f32(__n64 _Dm);
__n64 __vrndn_f32(__n64 _Dm);
__n64 __vrndp_f32(__n64 _Dm);
__n64 __vrndx_f32(__n64 _Dm);
__n128 __vrndq_f32(__n128 _Qm);
__n128 __vrndaq_f32(__n128 _Qm);
__n128 __vrndmq_f32(__n128 _Qm);
__n128 __vrndnq_f32(__n128 _Qm);
__n128 __vrndpq_f32(__n128 _Qm);
__n128 __vrndxq_f32(__n128 _Qm);
__n64 __vrsqrts_f32(__n64 _Dn, __n64 _Dm);
__n128 __vrsqrtsq_f32(__n128 _Qn, __n128 _Qm);
__n64 __vshl_n_s16(__n64 _Dm, const int _Shift_amount);
__n64 __vshl_n_s32(__n64 _Dm, const int _Shift_amount);
__n64 __vshl_n_s64(__n64 _Dm, const int _Shift_amount);
__n64 __vshl_n_s8(__n64 _Dm, const int _Shift_amount);
__n64 __vshl_n_u16(__n64 _Dm, const int _Shift_amount);
__n64 __vshl_n_u32(__n64 _Dm, const int _Shift_amount);
__n64 __vshl_n_u64(__n64 _Dm, const int _Shift_amount);
__n64 __vshl_n_u8(__n64 _Dm, const int _Shift_amount);
__n128 __vshlq_n_s16(__n128 _Qm, const int _Shift_amount);
__n128 __vshlq_n_s32(__n128 _Qm, const int _Shift_amount);
__n128 __vshlq_n_s64(__n128 _Qm, const int _Shift_amount);
__n128 __vshlq_n_s8(__n128 _Qm, const int _Shift_amount);
__n128 __vshlq_n_u16(__n128 _Qm, const int _Shift_amount);
__n128 __vshlq_n_u32(__n128 _Qm, const int _Shift_amount);
__n128 __vshlq_n_u64(__n128 _Qm, const int _Shift_amount);
__n128 __vshlq_n_u8(__n128 _Qm, const int _Shift_amount);
__n64 __vqrshl_s16(__n64 _Dn, __n64 _Dm);
__n64 __vqrshl_s32(__n64 _Dn, __n64 _Dm);
__n64 __vqrshl_s64(__n64 _Dn, __n64 _Dm);
__n64 __vqrshl_s8(__n64 _Dn, __n64 _Dm);
__n64 __vqrshl_u16(__n64 _Dn, __n64 _Dm);
__n64 __vqrshl_u32(__n64 _Dn, __n64 _Dm);
__n64 __vqrshl_u64(__n64 _Dn, __n64 _Dm);
__n64 __vqrshl_u8(__n64 _Dn, __n64 _Dm);
__n64 __vqshl_s16(__n64 _Dn, __n64 _Dm);
__n64 __vqshl_s32(__n64 _Dn, __n64 _Dm);
__n64 __vqshl_s64(__n64 _Dn, __n64 _Dm);
__n64 __vqshl_s8(__n64 _Dn, __n64 _Dm);
__n64 __vqshl_u16(__n64 _Dn, __n64 _Dm);
__n64 __vqshl_u32(__n64 _Dn, __n64 _Dm);
__n64 __vqshl_u64(__n64 _Dn, __n64 _Dm);
__n64 __vqshl_u8(__n64 _Dn, __n64 _Dm);
__n64 __vrshl_s16(__n64 _Dn, __n64 _Dm);
__n64 __vrshl_s32(__n64 _Dn, __n64 _Dm);
__n64 __vrshl_s64(__n64 _Dn, __n64 _Dm);
__n64 __vrshl_s8(__n64 _Dn, __n64 _Dm);
__n64 __vrshl_u16(__n64 _Dn, __n64 _Dm);
__n64 __vrshl_u32(__n64 _Dn, __n64 _Dm);
__n64 __vrshl_u64(__n64 _Dn, __n64 _Dm);
__n64 __vrshl_u8(__n64 _Dn, __n64 _Dm);
__n64 __vshl_s16(__n64 _Dn, __n64 _Dm);
__n64 __vshl_s32(__n64 _Dn, __n64 _Dm);
__n64 __vshl_s64(__n64 _Dn, __n64 _Dm);
__n64 __vshl_s8(__n64 _Dn, __n64 _Dm);
__n64 __vshl_u16(__n64 _Dn, __n64 _Dm);
__n64 __vshl_u32(__n64 _Dn, __n64 _Dm);
__n64 __vshl_u64(__n64 _Dn, __n64 _Dm);
__n64 __vshl_u8(__n64 _Dn, __n64 _Dm);
__n128 __vqrshlq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vqrshlq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vqrshlq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vqrshlq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vqrshlq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vqrshlq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vqrshlq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vqrshlq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vqshlq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vqshlq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vqshlq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vqshlq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vqshlq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vqshlq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vqshlq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vqshlq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vrshlq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vrshlq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vrshlq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vrshlq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vrshlq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vrshlq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vrshlq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vrshlq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vshlq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vshlq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vshlq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vshlq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vshlq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vshlq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vshlq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vshlq_u8(__n128 _Qn, __n128 _Qm);
__n128 __vshll_n_s16(__n64 _Dm, const int _Shift_amount);
__n128 __vshll_n_s32(__n64 _Dm, const int _Shift_amount);
__n128 __vshll_n_s8(__n64 _Dm, const int _Shift_amount);
__n128 __vshll_n_u16(__n64 _Dm, const int _Shift_amount);
__n128 __vshll_n_u32(__n64 _Dm, const int _Shift_amount);
__n128 __vshll_n_u8(__n64 _Dm, const int _Shift_amount);
__n64 __vrshr_n_s16(__n64 _Dm, const int _Shift_amount);
__n64 __vrshr_n_s32(__n64 _Dm, const int _Shift_amount);
__n64 __vrshr_n_s64(__n64 _Dm, const int _Shift_amount);
__n64 __vrshr_n_s8(__n64 _Dm, const int _Shift_amount);
__n64 __vrshr_n_u16(__n64 _Dm, const int _Shift_amount);
__n64 __vrshr_n_u32(__n64 _Dm, const int _Shift_amount);
__n64 __vrshr_n_u64(__n64 _Dm, const int _Shift_amount);
__n64 __vrshr_n_u8(__n64 _Dm, const int _Shift_amount);
__n64 __vshr_n_s16(__n64 _Dm, const int _Shift_amount);
__n64 __vshr_n_s32(__n64 _Dm, const int _Shift_amount);
__n64 __vshr_n_s64(__n64 _Dm, const int _Shift_amount);
__n64 __vshr_n_s8(__n64 _Dm, const int _Shift_amount);
__n64 __vshr_n_u16(__n64 _Dm, const int _Shift_amount);
__n64 __vshr_n_u32(__n64 _Dm, const int _Shift_amount);
__n64 __vshr_n_u64(__n64 _Dm, const int _Shift_amount);
__n64 __vshr_n_u8(__n64 _Dm, const int _Shift_amount);
__n128 __vrshrq_n_s16(__n128 _Qm, const int _Shift_amount);
__n128 __vrshrq_n_s32(__n128 _Qm, const int _Shift_amount);
__n128 __vrshrq_n_s64(__n128 _Qm, const int _Shift_amount);
__n128 __vrshrq_n_s8(__n128 _Qm, const int _Shift_amount);
__n128 __vrshrq_n_u16(__n128 _Qm, const int _Shift_amount);
__n128 __vrshrq_n_u32(__n128 _Qm, const int _Shift_amount);
__n128 __vrshrq_n_u64(__n128 _Qm, const int _Shift_amount);
__n128 __vrshrq_n_u8(__n128 _Qm, const int _Shift_amount);
__n128 __vshrq_n_s16(__n128 _Qm, const int _Shift_amount);
__n128 __vshrq_n_s32(__n128 _Qm, const int _Shift_amount);
__n128 __vshrq_n_s64(__n128 _Qm, const int _Shift_amount);
__n128 __vshrq_n_s8(__n128 _Qm, const int _Shift_amount);
__n128 __vshrq_n_u16(__n128 _Qm, const int _Shift_amount);
__n128 __vshrq_n_u32(__n128 _Qm, const int _Shift_amount);
__n128 __vshrq_n_u64(__n128 _Qm, const int _Shift_amount);
__n128 __vshrq_n_u8(__n128 _Qm, const int _Shift_amount);
__n64 __vrshrn_n_s16(__n128 _Qm, const int _Shift_amount);
__n64 __vrshrn_n_s32(__n128 _Qm, const int _Shift_amount);
__n64 __vrshrn_n_s64(__n128 _Qm, const int _Shift_amount);
__n64 __vrshrn_n_u16(__n128 _Qm, const int _Shift_amount);
__n64 __vrshrn_n_u32(__n128 _Qm, const int _Shift_amount);
__n64 __vrshrn_n_u64(__n128 _Qm, const int _Shift_amount);
__n64 __vshrn_n_s16(__n128 _Qm, const int _Shift_amount);
__n64 __vshrn_n_s32(__n128 _Qm, const int _Shift_amount);
__n64 __vshrn_n_s64(__n128 _Qm, const int _Shift_amount);
__n64 __vshrn_n_u16(__n128 _Qm, const int _Shift_amount);
__n64 __vshrn_n_u32(__n128 _Qm, const int _Shift_amount);
__n64 __vshrn_n_u64(__n128 _Qm, const int _Shift_amount);
__n64 __vsli_n_p16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_p8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_s16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_s32(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_s64(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_s8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_u16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_u32(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_u64(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsli_n_u8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n128 __vsliq_n_p16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_p8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_s16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_s32(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_s64(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_s8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_u16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_u32(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_u64(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsliq_n_u8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n64 __vrsra_n_s16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vrsra_n_s32(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vrsra_n_s64(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vrsra_n_s8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vrsra_n_u16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vrsra_n_u32(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vrsra_n_u64(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vrsra_n_u8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsra_n_s16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsra_n_s32(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsra_n_s64(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsra_n_s8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsra_n_u16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsra_n_u32(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsra_n_u64(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsra_n_u8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n128 __vrsraq_n_s16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vrsraq_n_s32(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vrsraq_n_s64(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vrsraq_n_s8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vrsraq_n_u16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vrsraq_n_u32(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vrsraq_n_u64(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vrsraq_n_u8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsraq_n_s16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsraq_n_s32(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsraq_n_s64(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsraq_n_s8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsraq_n_u16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsraq_n_u32(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsraq_n_u64(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsraq_n_u8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n64 __vsri_n_p16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_p8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_s16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_s32(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_s64(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_s8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_u16(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_u32(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_u64(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n64 __vsri_n_u8(__n64 _Dd, __n64 _Dm, const int _Shift_amount);
__n128 __vsriq_n_p16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_p8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_s16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_s32(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_s64(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_s8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_u16(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_u32(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_u64(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
__n128 __vsriq_n_u8(__n128 _Qd, __n128 _Qm, const int _Shift_amount);
void __vst1_f32(_Out_writes_(2) float32_t * _PD, __n64 _D);
void __vst1_p16(_Out_writes_(4) poly16_t * _PD, __n64 _D);
void __vst1_p8(_Out_writes_(8) poly8_t * _PD, __n64 _D);
void __vst1_s16(_Out_writes_(4) int16_t * _PD, __n64 _D);
void __vst1_s32(_Out_writes_(2) int32_t * _PD, __n64 _D);
void __vst1_s64(_Out_writes_(1) int64_t * _PD, __n64 _D);
void __vst1_s8(_Out_writes_(8) int8_t * _PD, __n64 _D);
void __vst1_u16(_Out_writes_(4) uint16_t * _PD, __n64 _D);
void __vst1_u32(_Out_writes_(2) uint32_t * _PD, __n64 _D);
void __vst1_u64(_Out_writes_(1) uint64_t * _PD, __n64 _D);
void __vst1_u8(_Out_writes_(8) uint8_t * _PD, __n64 _D);
void __vst1_f32_ex(_Out_writes_(2) float32_t * _PD, __n64 _D, const int _Align);
void __vst1_p16_ex(_Out_writes_(4) poly16_t * _PD, __n64 _D, const int _Align);
void __vst1_p8_ex(_Out_writes_(8) poly8_t * _PD, __n64 _D, const int _Align);
void __vst1_s16_ex(_Out_writes_(4) int16_t * _PD, __n64 _D, const int _Align);
void __vst1_s32_ex(_Out_writes_(2) int32_t * _PD, __n64 _D, const int _Align);
void __vst1_s64_ex(_Out_writes_(1) int64_t * _PD, __n64 _D, const int _Align);
void __vst1_s8_ex(_Out_writes_(8) int8_t * _PD, __n64 _D, const int _Align);
void __vst1_u16_ex(_Out_writes_(4) uint16_t * _PD, __n64 _D, const int _Align);
void __vst1_u32_ex(_Out_writes_(2) uint32_t * _PD, __n64 _D, const int _Align);
void __vst1_u64_ex(_Out_writes_(1) uint64_t * _PD, __n64 _D, const int _Align);
void __vst1_u8_ex(_Out_writes_(8) uint8_t * _PD, __n64 _D, const int _Align);
void __vst1q_f32(_Out_writes_(4) float32_t * _PD, __n128 _Q);
void __vst1q_p16(_Out_writes_(8) poly16_t * _PD, __n128 _Q);
void __vst1q_p8(_Out_writes_(16) poly8_t * _PD, __n128 _Q);
void __vst1q_s16(_Out_writes_(8) int16_t * _PD, __n128 _Q);
void __vst1q_s32(_Out_writes_(4) int32_t * _PD, __n128 _Q);
void __vst1q_s64(_Out_writes_(2) int64_t * _PD, __n128 _Q);
void __vst1q_s8(_Out_writes_(16) int8_t * _PD, __n128 _Q);
void __vst1q_u16(_Out_writes_(8) uint16_t * _PD, __n128 _Q);
void __vst1q_u32(_Out_writes_(4) uint32_t * _PD, __n128 _Q);
void __vst1q_u64(_Out_writes_(2) uint64_t * _PD, __n128 _Q);
void __vst1q_u8(_Out_writes_(16) uint8_t * _PD, __n128 _Q);
void __vst1q_f32_ex(_Out_writes_(4) float32_t * _PD, __n128 _Q, const int _Align);
void __vst1q_p16_ex(_Out_writes_(8) poly16_t * _PD, __n128 _Q, const int _Align);
void __vst1q_p8_ex(_Out_writes_(16) poly8_t * _PD, __n128 _Q, const int _Align);
void __vst1q_s16_ex(_Out_writes_(8) int16_t * _PD, __n128 _Q, const int _Align);
void __vst1q_s32_ex(_Out_writes_(4) int32_t * _PD, __n128 _Q, const int _Align);
void __vst1q_s64_ex(_Out_writes_(2) int64_t * _PD, __n128 _Q, const int _Align);
void __vst1q_s8_ex(_Out_writes_(16) int8_t * _PD, __n128 _Q, const int _Align);
void __vst1q_u16_ex(_Out_writes_(8) uint16_t * _PD, __n128 _Q, const int _Align);
void __vst1q_u32_ex(_Out_writes_(4) uint32_t * _PD, __n128 _Q, const int _Align);
void __vst1q_u64_ex(_Out_writes_(2) uint64_t * _PD, __n128 _Q, const int _Align);
void __vst1q_u8_ex(_Out_writes_(16) uint8_t * _PD, __n128 _Q, const int _Align);
void __vst1_lane_f32(_Out_writes_(1) float32_t * _PD, __n64 _D, const int _Lane);
void __vst1_lane_p16(_Out_writes_(1) poly16_t * _PD, __n64 _D, const int _Lane);
void __vst1_lane_p8(_Out_writes_(1) poly8_t * _PD, __n64 _D, const int _Lane);
void __vst1_lane_s16(_Out_writes_(1) int16_t * _PD, __n64 _D, const int _Lane);
void __vst1_lane_s32(_Out_writes_(1) int32_t * _PD, __n64 _D, const int _Lane);
void __vst1_lane_s8(_Out_writes_(1) int8_t * _PD, __n64 _D, const int _Lane);
void __vst1_lane_u16(_Out_writes_(1) uint16_t * _PD, __n64 _D, const int _Lane);
void __vst1_lane_u32(_Out_writes_(1) uint32_t * _PD, __n64 _D, const int _Lane);
void __vst1_lane_u8(_Out_writes_(1) uint8_t * _PD, __n64 _D, const int _Lane);
void __vst1q_lane_f32(_Out_writes_(1) float32_t * _PD, __n128 _Q, const int _Lane);
void __vst1q_lane_p16(_Out_writes_(1) poly16_t * _PD, __n128 _Q, const int _Lane);
void __vst1q_lane_p8(_Out_writes_(1) poly8_t * _PD, __n128 _Q, const int _Lane);
void __vst1q_lane_s16(_Out_writes_(1) int16_t * _PD, __n128 _Q, const int _Lane);
void __vst1q_lane_s32(_Out_writes_(1) int32_t * _PD, __n128 _Q, const int _Lane);
void __vst1q_lane_s8(_Out_writes_(1) int8_t * _PD, __n128 _Q, const int _Lane);
void __vst1q_lane_u16(_Out_writes_(1) uint16_t * _PD, __n128 _Q, const int _Lane);
void __vst1q_lane_u32(_Out_writes_(1) uint32_t * _PD, __n128 _Q, const int _Lane);
void __vst1q_lane_u8(_Out_writes_(1) uint8_t * _PD, __n128 _Q, const int _Lane);
void __vst1_lane_f32_ex(_Out_writes_(1) float32_t * _PD, __n64 _D, const int _Lane, const int _Align);
void __vst1_lane_p16_ex(_Out_writes_(1) poly16_t * _PD, __n64 _D, const int _Lane, const int _Align);
void __vst1_lane_s16_ex(_Out_writes_(1) int16_t * _PD, __n64 _D, const int _Lane, const int _Align);
void __vst1_lane_s32_ex(_Out_writes_(1) int32_t * _PD, __n64 _D, const int _Lane, const int _Align);
void __vst1_lane_u16_ex(_Out_writes_(1) uint16_t * _PD, __n64 _D, const int _Lane, const int _Align);
void __vst1_lane_u32_ex(_Out_writes_(1) uint32_t * _PD, __n64 _D, const int _Lane, const int _Align);
void __vst1q_lane_f32_ex(_Out_writes_(1) float32_t * _PD, __n128 _Q, const int _Lane, const int _Align);
void __vst1q_lane_p16_ex(_Out_writes_(1) poly16_t * _PD, __n128 _Q, const int _Lane, const int _Align);
void __vst1q_lane_s16_ex(_Out_writes_(1) int16_t * _PD, __n128 _Q, const int _Lane, const int _Align);
void __vst1q_lane_s32_ex(_Out_writes_(1) int32_t * _PD, __n128 _Q, const int _Lane, const int _Align);
void __vst1q_lane_u16_ex(_Out_writes_(1) uint16_t * _PD, __n128 _Q, const int _Lane, const int _Align);
void __vst1q_lane_u32_ex(_Out_writes_(1) uint32_t * _PD, __n128 _Q, const int _Lane, const int _Align);
void __vst2_f32(_Out_writes_(4) float32_t * _PD, __n64x2 _D2);
void __vst2_p16(_Out_writes_(8) poly16_t * _PD, __n64x2 _D2);
void __vst2_p8(_Out_writes_(16) poly8_t * _PD, __n64x2 _D2);
void __vst2_s16(_Out_writes_(8) int16_t * _PD, __n64x2 _D2);
void __vst2_s32(_Out_writes_(4) int32_t * _PD, __n64x2 _D2);
void __vst2_s8(_Out_writes_(16) int8_t * _PD, __n64x2 _D2);
void __vst2_u16(_Out_writes_(8) uint16_t * _PD, __n64x2 _D2);
void __vst2_u32(_Out_writes_(4) uint32_t * _PD, __n64x2 _D2);
void __vst2_u8(_Out_writes_(16) uint8_t * _PD, __n64x2 _D2);
void __vst2_s64(_Out_writes_(2) int64_t * _PD, __n64x2 _D2);
void __vst2_u64(_Out_writes_(2) uint64_t * _PD, __n64x2 _D2);
void __vst2_s64_ex(_Out_writes_(2) int64_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_u64_ex(_Out_writes_(2) uint64_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_f32_ex(_Out_writes_(4) float32_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_p16_ex(_Out_writes_(8) poly16_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_p8_ex(_Out_writes_(16) poly8_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_s16_ex(_Out_writes_(8) int16_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_s32_ex(_Out_writes_(4) int32_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_s8_ex(_Out_writes_(16) int8_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_u16_ex(_Out_writes_(8) uint16_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_u32_ex(_Out_writes_(4) uint32_t * _PD, __n64x2 _D2, const int _Align);
void __vst2_u8_ex(_Out_writes_(16) uint8_t * _PD, __n64x2 _D2, const int _Align);
void __vst2q_f32(_Out_writes_(8) float32_t * _PD, __n128x2 _Q2);
void __vst2q_p16(_Out_writes_(16) poly16_t * _PD, __n128x2 _Q2);
void __vst2q_p8(_Out_writes_(32) poly8_t * _PD, __n128x2 _Q2);
void __vst2q_s16(_Out_writes_(16) int16_t * _PD, __n128x2 _Q2);
void __vst2q_s32(_Out_writes_(8) int32_t * _PD, __n128x2 _Q2);
void __vst2q_s8(_Out_writes_(32) int8_t * _PD, __n128x2 _Q2);
void __vst2q_u16(_Out_writes_(16) uint16_t * _PD, __n128x2 _Q2);
void __vst2q_u32(_Out_writes_(8) uint32_t * _PD, __n128x2 _Q2);
void __vst2q_u8(_Out_writes_(32) uint8_t * _PD, __n128x2 _Q2);
void __vst2q_f32_ex(_Out_writes_(8) float32_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2q_p16_ex(_Out_writes_(16) poly16_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2q_p8_ex(_Out_writes_(32) poly8_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2q_s16_ex(_Out_writes_(16) int16_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2q_s32_ex(_Out_writes_(8) int32_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2q_s8_ex(_Out_writes_(32) int8_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2q_u16_ex(_Out_writes_(16) uint16_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2q_u32_ex(_Out_writes_(8) uint32_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2q_u8_ex(_Out_writes_(32) uint8_t * _PD, __n128x2 _Q2, const int _Align);
void __vst2_lane_f32(_Out_writes_(2) float32_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2_lane_p16(_Out_writes_(2) poly16_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2_lane_p8(_Out_writes_(2) poly8_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2_lane_s16(_Out_writes_(2) int16_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2_lane_s32(_Out_writes_(2) int32_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2_lane_s8(_Out_writes_(2) int8_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2_lane_u16(_Out_writes_(2) uint16_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2_lane_u32(_Out_writes_(2) uint32_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2_lane_u8(_Out_writes_(2) uint8_t * _PD, __n64x2 _D2, const int _Lane);
void __vst2q_lane_f32(_Out_writes_(2) float32_t * _PD, __n128x2 _Q2, const int _Lane);
void __vst2q_lane_p16(_Out_writes_(2) poly16_t * _PD, __n128x2 _Q2, const int _Lane);
void __vst2q_lane_s16(_Out_writes_(2) int16_t * _PD, __n128x2 _Q2, const int _Lane);
void __vst2q_lane_s32(_Out_writes_(2) int32_t * _PD, __n128x2 _Q2, const int _Lane);
void __vst2q_lane_u16(_Out_writes_(2) uint16_t * _PD, __n128x2 _Q2, const int _Lane);
void __vst2q_lane_u32(_Out_writes_(2) uint32_t * _PD, __n128x2 _Q2, const int _Lane);
void __vst2_lane_f32_ex(_Out_writes_(2) float32_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2_lane_p16_ex(_Out_writes_(2) poly16_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2_lane_p8_ex(_Out_writes_(2) poly8_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2_lane_s16_ex(_Out_writes_(2) int16_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2_lane_s32_ex(_Out_writes_(2) int32_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2_lane_s8_ex(_Out_writes_(2) int8_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2_lane_u16_ex(_Out_writes_(2) uint16_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2_lane_u32_ex(_Out_writes_(2) uint32_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2_lane_u8_ex(_Out_writes_(2) uint8_t * _PD, __n64x2 _D2, const int _Lane, const int _Align);
void __vst2q_lane_f32_ex(_Out_writes_(2) float32_t * _PD, __n128x2 _Q2, const int _Lane, const int _Align);
void __vst2q_lane_p16_ex(_Out_writes_(2) poly16_t * _PD, __n128x2 _Q2, const int _Lane, const int _Align);
void __vst2q_lane_s16_ex(_Out_writes_(2) int16_t * _PD, __n128x2 _Q2, const int _Lane, const int _Align);
void __vst2q_lane_s32_ex(_Out_writes_(2) int32_t * _PD, __n128x2 _Q2, const int _Lane, const int _Align);
void __vst2q_lane_u16_ex(_Out_writes_(2) uint16_t * _PD, __n128x2 _Q2, const int _Lane, const int _Align);
void __vst2q_lane_u32_ex(_Out_writes_(2) uint32_t * _PD, __n128x2 _Q2, const int _Lane, const int _Align);
void __vst3_f32(_Out_writes_(6) float32_t * _PD, __n64x3 _D3);
void __vst3_p16(_Out_writes_(12) poly16_t * _PD, __n64x3 _D3);
void __vst3_p8(_Out_writes_(24) poly8_t * _PD, __n64x3 _D3);
void __vst3_s16(_Out_writes_(12) int16_t * _PD, __n64x3 _D3);
void __vst3_s32(_Out_writes_(6) int32_t * _PD, __n64x3 _D3);
void __vst3_s8(_Out_writes_(24) int8_t * _PD, __n64x3 _D3);
void __vst3_u16(_Out_writes_(12) uint16_t * _PD, __n64x3 _D3);
void __vst3_u32(_Out_writes_(6) uint32_t * _PD, __n64x3 _D3);
void __vst3_u8(_Out_writes_(24) uint8_t * _PD, __n64x3 _D3);
void __vst3_s64(_Out_writes_(3) int64_t * _PD, __n64x3 _D3);
void __vst3_u64(_Out_writes_(3) uint64_t * _PD, __n64x3 _D3);
void __vst3_s64_ex(_Out_writes_(3) int64_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_u64_ex(_Out_writes_(3) uint64_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_f32_ex(_Out_writes_(6) float32_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_p16_ex(_Out_writes_(12) poly16_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_p8_ex(_Out_writes_(24) poly8_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_s16_ex(_Out_writes_(12) int16_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_s32_ex(_Out_writes_(6) int32_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_s8_ex(_Out_writes_(24) int8_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_u16_ex(_Out_writes_(12) uint16_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_u32_ex(_Out_writes_(6) uint32_t * _PD, __n64x3 _D3, const int _Align);
void __vst3_u8_ex(_Out_writes_(24) uint8_t * _PD, __n64x3 _D3, const int _Align);
void __vst3q_f32(_Out_writes_(12) float32_t * _PD, __n128x3 _Q3);
void __vst3q_p16(_Out_writes_(24) poly16_t * _PD, __n128x3 _Q3);
void __vst3q_p8(_Out_writes_(48) poly8_t * _PD, __n128x3 _Q3);
void __vst3q_s16(_Out_writes_(24) int16_t * _PD, __n128x3 _Q3);
void __vst3q_s32(_Out_writes_(12) int32_t * _PD, __n128x3 _Q3);
void __vst3q_s8(_Out_writes_(48) int8_t * _PD, __n128x3 _Q3);
void __vst3q_u16(_Out_writes_(24) uint16_t * _PD, __n128x3 _Q3);
void __vst3q_u32(_Out_writes_(12) uint32_t * _PD, __n128x3 _Q3);
void __vst3q_u8(_Out_writes_(48) uint8_t * _PD, __n128x3 _Q3);
void __vst3q_f32_ex(_Out_writes_(12) float32_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3q_p16_ex(_Out_writes_(24) poly16_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3q_p8_ex(_Out_writes_(48) poly8_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3q_s16_ex(_Out_writes_(24) int16_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3q_s32_ex(_Out_writes_(12) int32_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3q_s8_ex(_Out_writes_(48) int8_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3q_u16_ex(_Out_writes_(24) uint16_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3q_u32_ex(_Out_writes_(12) uint32_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3q_u8_ex(_Out_writes_(48) uint8_t * _PD, __n128x3 _Q3, const int _Align);
void __vst3_lane_f32(_Out_writes_(3) float32_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3_lane_p16(_Out_writes_(3) poly16_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3_lane_p8(_Out_writes_(3) poly8_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3_lane_s16(_Out_writes_(3) int16_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3_lane_s32(_Out_writes_(3) int32_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3_lane_s8(_Out_writes_(3) int8_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3_lane_u16(_Out_writes_(3) uint16_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3_lane_u32(_Out_writes_(3) uint32_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3_lane_u8(_Out_writes_(3) uint8_t * _PD, __n64x3 _D3, const int _Lane);
void __vst3q_lane_f32(_Out_writes_(3) float32_t * _PD, __n128x3 _Q3, const int _Lane);
void __vst3q_lane_p16(_Out_writes_(3) poly16_t * _PD, __n128x3 _Q3, const int _Lane);
void __vst3q_lane_s16(_Out_writes_(3) int16_t * _PD, __n128x3 _Q3, const int _Lane);
void __vst3q_lane_s32(_Out_writes_(3) int32_t * _PD, __n128x3 _Q3, const int _Lane);
void __vst3q_lane_u16(_Out_writes_(3) uint16_t * _PD, __n128x3 _Q3, const int _Lane);
void __vst3q_lane_u32(_Out_writes_(3) uint32_t * _PD, __n128x3 _Q3, const int _Lane);
void __vst4_f32(_Out_writes_(8) float32_t * _PD, __n64x4 _D4);
void __vst4_p16(_Out_writes_(16) poly16_t * _PD, __n64x4 _D4);
void __vst4_p8(_Out_writes_(32) poly8_t * _PD, __n64x4 _D4);
void __vst4_s16(_Out_writes_(16) int16_t * _PD, __n64x4 _D4);
void __vst4_s32(_Out_writes_(8) int32_t * _PD, __n64x4 _D4);
void __vst4_s8(_Out_writes_(32) int8_t * _PD, __n64x4 _D4);
void __vst4_u16(_Out_writes_(16) uint16_t * _PD, __n64x4 _D4);
void __vst4_u32(_Out_writes_(8) uint32_t * _PD, __n64x4 _D4);
void __vst4_u8(_Out_writes_(32) uint8_t * _PD, __n64x4 _D4);
void __vst4_s64(_Out_writes_(4) int64_t * _PD, __n64x4 _D4);
void __vst4_u64(_Out_writes_(4) uint64_t * _PD, __n64x4 _D4);
void __vst4_s64_ex(_Out_writes_(4) int64_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_u64_ex(_Out_writes_(4) uint64_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_f32_ex(_Out_writes_(8) float32_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_p16_ex(_Out_writes_(16) poly16_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_p8_ex(_Out_writes_(32) poly8_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_s16_ex(_Out_writes_(16) int16_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_s32_ex(_Out_writes_(8) int32_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_s8_ex(_Out_writes_(32) int8_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_u16_ex(_Out_writes_(16) uint16_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_u32_ex(_Out_writes_(8) uint32_t * _PD, __n64x4 _D4, const int _Align);
void __vst4_u8_ex(_Out_writes_(32) uint8_t * _PD, __n64x4 _D4, const int _Align);
void __vst4q_f32(_Out_writes_(16) float32_t * _PD, __n128x4 _Q4);
void __vst4q_p16(_Out_writes_(32) poly16_t * _PD, __n128x4 _Q4);
void __vst4q_p8(_Out_writes_(64) poly8_t * _PD, __n128x4 _Q4);
void __vst4q_s16(_Out_writes_(32) int16_t * _PD, __n128x4 _Q4);
void __vst4q_s32(_Out_writes_(16) int32_t * _PD, __n128x4 _Q4);
void __vst4q_s8(_Out_writes_(64) int8_t * _PD, __n128x4 _Q4);
void __vst4q_u16(_Out_writes_(32) uint16_t * _PD, __n128x4 _Q4);
void __vst4q_u32(_Out_writes_(16) uint32_t * _PD, __n128x4 _Q4);
void __vst4q_u8(_Out_writes_(64) uint8_t * _PD, __n128x4 _Q4);
void __vst4q_f32_ex(_Out_writes_(16) float32_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4q_p16_ex(_Out_writes_(32) poly16_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4q_p8_ex(_Out_writes_(64) poly8_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4q_s16_ex(_Out_writes_(32) int16_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4q_s32_ex(_Out_writes_(16) int32_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4q_s8_ex(_Out_writes_(64) int8_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4q_u16_ex(_Out_writes_(32) uint16_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4q_u32_ex(_Out_writes_(16) uint32_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4q_u8_ex(_Out_writes_(64) uint8_t * _PD, __n128x4 _Q4, const int _Align);
void __vst4_lane_f32(_Out_writes_(4) float32_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4_lane_p16(_Out_writes_(4) poly16_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4_lane_p8(_Out_writes_(4) poly8_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4_lane_s16(_Out_writes_(4) int16_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4_lane_s32(_Out_writes_(4) int32_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4_lane_s8(_Out_writes_(4) int8_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4_lane_u16(_Out_writes_(4) uint16_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4_lane_u32(_Out_writes_(4) uint32_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4_lane_u8(_Out_writes_(4) uint8_t * _PD, __n64x4 _D4, const int _Lane);
void __vst4q_lane_f32(_Out_writes_(4) float32_t * _PD, __n128x4 _Q4, const int _Lane);
void __vst4q_lane_p16(_Out_writes_(4) poly16_t * _PD, __n128x4 _Q4, const int _Lane);
void __vst4q_lane_s16(_Out_writes_(4) int16_t * _PD, __n128x4 _Q4, const int _Lane);
void __vst4q_lane_s32(_Out_writes_(4) int32_t * _PD, __n128x4 _Q4, const int _Lane);
void __vst4q_lane_u16(_Out_writes_(4) uint16_t * _PD, __n128x4 _Q4, const int _Lane);
void __vst4q_lane_u32(_Out_writes_(4) uint32_t * _PD, __n128x4 _Q4, const int _Lane);
void __vst4_lane_f32_ex(_Out_writes_(4) float32_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4_lane_p16_ex(_Out_writes_(4) poly16_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4_lane_p8_ex(_Out_writes_(4) poly8_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4_lane_s16_ex(_Out_writes_(4) int16_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4_lane_s32_ex(_Out_writes_(4) int32_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4_lane_s8_ex(_Out_writes_(4) int8_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4_lane_u16_ex(_Out_writes_(4) uint16_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4_lane_u32_ex(_Out_writes_(4) uint32_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4_lane_u8_ex(_Out_writes_(4) uint8_t * _PD, __n64x4 _D4, const int _Lane, const int _Align);
void __vst4q_lane_f32_ex(_Out_writes_(4) float32_t * _PD, __n128x4 _Q4, const int _Lane, const int _Align);
void __vst4q_lane_p16_ex(_Out_writes_(4) poly16_t * _PD, __n128x4 _Q4, const int _Lane, const int _Align);
void __vst4q_lane_s16_ex(_Out_writes_(4) int16_t * _PD, __n128x4 _Q4, const int _Lane, const int _Align);
void __vst4q_lane_s32_ex(_Out_writes_(4) int32_t * _PD, __n128x4 _Q4, const int _Lane, const int _Align);
void __vst4q_lane_u16_ex(_Out_writes_(4) uint16_t * _PD, __n128x4 _Q4, const int _Lane, const int _Align);
void __vst4q_lane_u32_ex(_Out_writes_(4) uint32_t * _PD, __n128x4 _Q4, const int _Lane, const int _Align);
__n64 __vsub_f32(__n64 _Dn, __n64 _Dm);
__n64 __vsub_s16(__n64 _Dn, __n64 _Dm);
__n64 __vsub_s32(__n64 _Dn, __n64 _Dm);
__n64 __vsub_s64(__n64 _Dn, __n64 _Dm);
__n64 __vsub_s8(__n64 _Dn, __n64 _Dm);
__n64 __vsub_u16(__n64 _Dn, __n64 _Dm);
__n64 __vsub_u32(__n64 _Dn, __n64 _Dm);
__n64 __vsub_u64(__n64 _Dn, __n64 _Dm);
__n64 __vsub_u8(__n64 _Dn, __n64 _Dm);
__n128 __vsubq_f32(__n128 _Qn, __n128 _Qm);
__n128 __vsubq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vsubq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vsubq_s64(__n128 _Qn, __n128 _Qm);
__n128 __vsubq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vsubq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vsubq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vsubq_u64(__n128 _Qn, __n128 _Qm);
__n128 __vsubq_u8(__n128 _Qn, __n128 _Qm);
__n64 __vrsubhn_s16(__n128 _Qn, __n128 _Qm);
__n64 __vrsubhn_s32(__n128 _Qn, __n128 _Qm);
__n64 __vrsubhn_s64(__n128 _Qn, __n128 _Qm);
__n64 __vrsubhn_u16(__n128 _Qn, __n128 _Qm);
__n64 __vrsubhn_u32(__n128 _Qn, __n128 _Qm);
__n64 __vrsubhn_u64(__n128 _Qn, __n128 _Qm);
__n64 __vsubhn_s16(__n128 _Qn, __n128 _Qm);
__n64 __vsubhn_s32(__n128 _Qn, __n128 _Qm);
__n64 __vsubhn_s64(__n128 _Qn, __n128 _Qm);
__n64 __vsubhn_u16(__n128 _Qn, __n128 _Qm);
__n64 __vsubhn_u32(__n128 _Qn, __n128 _Qm);
__n64 __vsubhn_u64(__n128 _Qn, __n128 _Qm);
__n128 __vsubl_s16(__n64 _Dn, __n64 _Dm);
__n128 __vsubl_s32(__n64 _Dn, __n64 _Dm);
__n128 __vsubl_s8(__n64 _Dn, __n64 _Dm);
__n128 __vsubl_u16(__n64 _Dn, __n64 _Dm);
__n128 __vsubl_u32(__n64 _Dn, __n64 _Dm);
__n128 __vsubl_u8(__n64 _Dn, __n64 _Dm);
__n128 __vsubw_s16(__n128 _Qn, __n64 _Dm);
__n128 __vsubw_s32(__n128 _Qn, __n64 _Dm);
__n128 __vsubw_s8(__n128 _Qn, __n64 _Dm);
__n128 __vsubw_u16(__n128 _Qn, __n64 _Dm);
__n128 __vsubw_u32(__n128 _Qn, __n64 _Dm);
__n128 __vsubw_u8(__n128 _Qn, __n64 _Dm);
__n64 __vtbl2_p8(__n64x2 _D2, __n64 _Dm);
__n64 __vtbl2_s8(__n64x2 _D2, __n64 _Dm);
__n64 __vtbl2_u8(__n64x2 _D2, __n64 _Dm);
__n64 __vtbx2_p8(__n64 _Dd, __n64x2 _D2, __n64 _Dm);
__n64 __vtbx2_s8(__n64 _Dd, __n64x2 _D2, __n64 _Dm);
__n64 __vtbx2_u8(__n64 _Dd, __n64x2 _D2, __n64 _Dm);
__n64 __vtbl3_p8(__n64x3 _D3, __n64 _Dm);
__n64 __vtbl3_s8(__n64x3 _D3, __n64 _Dm);
__n64 __vtbl3_u8(__n64x3 _D3, __n64 _Dm);
__n64 __vtbx3_p8(__n64 _Dd, __n64x3 _D3, __n64 _Dm);
__n64 __vtbx3_s8(__n64 _Dd, __n64x3 _D3, __n64 _Dm);
__n64 __vtbx3_u8(__n64 _Dd, __n64x3 _D3, __n64 _Dm);
__n64 __vtbl4_p8(__n64x4 _D4, __n64 _Dm);
__n64 __vtbl4_s8(__n64x4 _D4, __n64 _Dm);
__n64 __vtbl4_u8(__n64x4 _D4, __n64 _Dm);
__n64 __vtbx4_p8(__n64 _Dd, __n64x4 _D4, __n64 _Dm);
__n64 __vtbx4_s8(__n64 _Dd, __n64x4 _D4, __n64 _Dm);
__n64 __vtbx4_u8(__n64 _Dd, __n64x4 _D4, __n64 _Dm);
__n64 __vtbl1_p8(__n64 _Dn, __n64 _Dm);
__n64 __vtbl1_s8(__n64 _Dn, __n64 _Dm);
__n64 __vtbl1_u8(__n64 _Dn, __n64 _Dm);
__n64 __vtbx1_p8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vtbx1_s8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64 __vtbx1_u8(__n64 _Dd, __n64 _Dn, __n64 _Dm);
__n64x2 __vtrn_f32(__n64 _Dd, __n64 _Dm);
__n64x2 __vtrn_p16(__n64 _Dd, __n64 _Dm);
__n64x2 __vtrn_p8(__n64 _Dd, __n64 _Dm);
__n64x2 __vtrn_s16(__n64 _Dd, __n64 _Dm);
__n64x2 __vtrn_s32(__n64 _Dd, __n64 _Dm);
__n64x2 __vtrn_s8(__n64 _Dd, __n64 _Dm);
__n64x2 __vtrn_u16(__n64 _Dd, __n64 _Dm);
__n64x2 __vtrn_u32(__n64 _Dd, __n64 _Dm);
__n64x2 __vtrn_u8(__n64 _Dd, __n64 _Dm);
__n128x2 __vtrnq_f32(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_p16(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_p8(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_s16(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_s32(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_s8(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_u16(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_u32(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_u8(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_s64(__n128 _Qd, __n128 _Qm);
__n128x2 __vtrnq_u64(__n128 _Qd, __n128 _Qm);
__n64 __vtst_p8(__n64 _Dn, __n64 _Dm);
__n64 __vtst_s16(__n64 _Dn, __n64 _Dm);
__n64 __vtst_s32(__n64 _Dn, __n64 _Dm);
__n64 __vtst_s8(__n64 _Dn, __n64 _Dm);
__n64 __vtst_u16(__n64 _Dn, __n64 _Dm);
__n64 __vtst_u32(__n64 _Dn, __n64 _Dm);
__n64 __vtst_u8(__n64 _Dn, __n64 _Dm);
__n128 __vtstq_p8(__n128 _Qn, __n128 _Qm);
__n128 __vtstq_s16(__n128 _Qn, __n128 _Qm);
__n128 __vtstq_s32(__n128 _Qn, __n128 _Qm);
__n128 __vtstq_s8(__n128 _Qn, __n128 _Qm);
__n128 __vtstq_u16(__n128 _Qn, __n128 _Qm);
__n128 __vtstq_u32(__n128 _Qn, __n128 _Qm);
__n128 __vtstq_u8(__n128 _Qn, __n128 _Qm);
__n64x2 __vuzp_p16(__n64 _Dd, __n64 _Dm);
__n64x2 __vuzp_p8(__n64 _Dd, __n64 _Dm);
__n64x2 __vuzp_s16(__n64 _Dd, __n64 _Dm);
__n64x2 __vuzp_s8(__n64 _Dd, __n64 _Dm);
__n64x2 __vuzp_u16(__n64 _Dd, __n64 _Dm);
__n64x2 __vuzp_u8(__n64 _Dd, __n64 _Dm);
__n64x2 __vuzp_f32(__n64 _Dd, __n64 _Dm);
__n64x2 __vuzp_s32(__n64 _Dd, __n64 _Dm);
__n64x2 __vuzp_u32(__n64 _Dd, __n64 _Dm);
__n128x2 __vuzpq_f32(__n128 _Qd, __n128 _Qm);
__n128x2 __vuzpq_p16(__n128 _Qd, __n128 _Qm);
__n128x2 __vuzpq_p8(__n128 _Qd, __n128 _Qm);
__n128x2 __vuzpq_s16(__n128 _Qd, __n128 _Qm);
__n128x2 __vuzpq_s32(__n128 _Qd, __n128 _Qm);
__n128x2 __vuzpq_s8(__n128 _Qd, __n128 _Qm);
__n128x2 __vuzpq_u16(__n128 _Qd, __n128 _Qm);
__n128x2 __vuzpq_u32(__n128 _Qd, __n128 _Qm);
__n128x2 __vuzpq_u8(__n128 _Qd, __n128 _Qm);
__n64x2 __vzip_p16(__n64 _Dd, __n64 _Dm);
__n64x2 __vzip_p8(__n64 _Dd, __n64 _Dm);
__n64x2 __vzip_s16(__n64 _Dd, __n64 _Dm);
__n64x2 __vzip_s8(__n64 _Dd, __n64 _Dm);
__n64x2 __vzip_u16(__n64 _Dd, __n64 _Dm);
__n64x2 __vzip_u8(__n64 _Dd, __n64 _Dm);
__n64x2 __vzip_f32(__n64 _Dd, __n64 _Dm);
__n64x2 __vzip_s32(__n64 _Dd, __n64 _Dm);
__n64x2 __vzip_u32(__n64 _Dd, __n64 _Dm);
__n128x2 __vzipq_f32(__n128 _Qd, __n128 _Qm);
__n128x2 __vzipq_p16(__n128 _Qd, __n128 _Qm);
__n128x2 __vzipq_p8(__n128 _Qd, __n128 _Qm);
__n128x2 __vzipq_s16(__n128 _Qd, __n128 _Qm);
__n128x2 __vzipq_s32(__n128 _Qd, __n128 _Qm);
__n128x2 __vzipq_s8(__n128 _Qd, __n128 _Qm);
__n128x2 __vzipq_u16(__n128 _Qd, __n128 _Qm);
__n128x2 __vzipq_u32(__n128 _Qd, __n128 _Qm);
__n128x2 __vzipq_u8(__n128 _Qd, __n128 _Qm);

// AESD/AESE/AESIMC/AESMC
#define vaesdq_u8(src1, src2)   __aesd_u8(src1, src2)
#define vaeseq_u8(src1, src2)   __aese_u8(src1, src2)
#define vaesimcq_u8(src)        __aesimc_u8(src)
#define vaesmcq_u8(src)         __aesmc_u8(src)

// SHA1C/SHA1H/SHA1M/SHA1P/SHA1SU0/SHA1SU1/SHA256H/SHA256H2/SHA256SU0/SHA256SU1/
#define vsha1cq_u32(src1, src2, src3)       __sha1c_u32(src1, __vmovq_n_u32(src2), src3)
#define vsha1h_u32(src)                     __vgetq_lane_u32(__sha1h_u32(__vmovq_n_u32(src)), 0)
#define vsha1mq_u32(src1, src2, src3)       __sha1m_u32(src1, __vmovq_n_u32(src2), src3)
#define vsha1pq_u32(src1, src2, src3)       __sha1p_u32(src1, __vmovq_n_u32(src2), src3)
#define vsha1su0q_u32(src1, src2, src3)     __sha1su0_u32(src1, src2, src3)
#define vsha1su1q_u32(src1, src2)           __sha1su1_u32(src1, src2)
#define vsha256hq_u32(src1, src2, src3)     __sha256h_u32(src1, src2, src3)
#define vsha256h2q_u32(src1, src2, src3)    __sha256h2_u32(src1, src2, src3)
#define vsha256su0q_u32(src1, src2)         __sha256su0_u32(src1, src2)
#define vsha256su1q_u32(src1, src2, src3)   __sha256su1_u32(src1, src2, src3)

// Type reinterpretation no-ops
#define __vreinterpret_f32_s8(a)    (a)
#define __vreinterpret_f32_s16(a)   (a)
#define __vreinterpret_f32_s32(a)   (a)
#define __vreinterpret_f32_s64(a)   (a)
#define __vreinterpret_f32_p8(a)    (a)
#define __vreinterpret_f32_p16(a)   (a)
#define __vreinterpret_f32_u8(a)    (a)
#define __vreinterpret_f32_u16(a)   (a)
#define __vreinterpret_f32_u32(a)   (a)
#define __vreinterpret_f32_u64(a)   (a)
#define __vreinterpret_s8_f32(a)    (a)
#define __vreinterpret_s8_s16(a)    (a)
#define __vreinterpret_s8_s32(a)    (a)
#define __vreinterpret_s8_s64(a)    (a)
#define __vreinterpret_s8_p8(a)     (a)
#define __vreinterpret_s8_p16(a)    (a)
#define __vreinterpret_s8_u8(a)     (a)
#define __vreinterpret_s8_u16(a)    (a)
#define __vreinterpret_s8_u32(a)    (a)
#define __vreinterpret_s8_u64(a)    (a)
#define __vreinterpret_s16_f32(a)   (a)
#define __vreinterpret_s16_s8(a)    (a)
#define __vreinterpret_s16_s32(a)   (a)
#define __vreinterpret_s16_s64(a)   (a)
#define __vreinterpret_s16_p8(a)    (a)
#define __vreinterpret_s16_p16(a)   (a)
#define __vreinterpret_s16_u8(a)    (a)
#define __vreinterpret_s16_u16(a)   (a)
#define __vreinterpret_s16_u32(a)   (a)
#define __vreinterpret_s16_u64(a)   (a)
#define __vreinterpret_s32_f32(a)   (a)
#define __vreinterpret_s32_s8(a)    (a)
#define __vreinterpret_s32_s16(a)   (a)
#define __vreinterpret_s32_s64(a)   (a)
#define __vreinterpret_s32_p8(a)    (a)
#define __vreinterpret_s32_p16(a)   (a)
#define __vreinterpret_s32_u8(a)    (a)
#define __vreinterpret_s32_u16(a)   (a)
#define __vreinterpret_s32_u32(a)   (a)
#define __vreinterpret_s32_u64(a)   (a)
#define __vreinterpret_s64_f32(a)   (a)
#define __vreinterpret_s64_s8(a)    (a)
#define __vreinterpret_s64_s16(a)   (a)
#define __vreinterpret_s64_s32(a)   (a)
#define __vreinterpret_s64_p8(a)    (a)
#define __vreinterpret_s64_p16(a)   (a)
#define __vreinterpret_s64_u8(a)    (a)
#define __vreinterpret_s64_u16(a)   (a)
#define __vreinterpret_s64_u32(a)   (a)
#define __vreinterpret_s64_u64(a)   (a)
#define __vreinterpret_p8_f32(a)    (a)
#define __vreinterpret_p8_s8(a)     (a)
#define __vreinterpret_p8_s16(a)    (a)
#define __vreinterpret_p8_s32(a)    (a)
#define __vreinterpret_p8_s64(a)    (a)
#define __vreinterpret_p8_p16(a)    (a)
#define __vreinterpret_p8_u8(a)     (a)
#define __vreinterpret_p8_u16(a)    (a)
#define __vreinterpret_p8_u32(a)    (a)
#define __vreinterpret_p8_u64(a)    (a)
#define __vreinterpret_p16_f32(a)   (a)
#define __vreinterpret_p16_s8(a)    (a)
#define __vreinterpret_p16_s16(a)   (a)
#define __vreinterpret_p16_s32(a)   (a)
#define __vreinterpret_p16_s64(a)   (a)
#define __vreinterpret_p16_p8(a)    (a)
#define __vreinterpret_p16_u8(a)    (a)
#define __vreinterpret_p16_u16(a)   (a)
#define __vreinterpret_p16_u32(a)   (a)
#define __vreinterpret_p16_u64(a)   (a)
#define __vreinterpret_u8_f32(a)    (a)
#define __vreinterpret_u8_s8(a)     (a)
#define __vreinterpret_u8_s16(a)    (a)
#define __vreinterpret_u8_s32(a)    (a)
#define __vreinterpret_u8_s64(a)    (a)
#define __vreinterpret_u8_p8(a)     (a)
#define __vreinterpret_u8_p16(a)    (a)
#define __vreinterpret_u8_u16(a)    (a)
#define __vreinterpret_u8_u32(a)    (a)
#define __vreinterpret_u8_u64(a)    (a)
#define __vreinterpret_u16_f32(a)   (a)
#define __vreinterpret_u16_s8(a)    (a)
#define __vreinterpret_u16_s16(a)   (a)
#define __vreinterpret_u16_s32(a)   (a)
#define __vreinterpret_u16_s64(a)   (a)
#define __vreinterpret_u16_p8(a)    (a)
#define __vreinterpret_u16_p16(a)   (a)
#define __vreinterpret_u16_u8(a)    (a)
#define __vreinterpret_u16_u32(a)   (a)
#define __vreinterpret_u16_u64(a)   (a)
#define __vreinterpret_u32_f32(a)   (a)
#define __vreinterpret_u32_s8(a)    (a)
#define __vreinterpret_u32_s16(a)   (a)
#define __vreinterpret_u32_s32(a)   (a)
#define __vreinterpret_u32_s64(a)   (a)
#define __vreinterpret_u32_p8(a)    (a)
#define __vreinterpret_u32_p16(a)   (a)
#define __vreinterpret_u32_u8(a)    (a)
#define __vreinterpret_u32_u16(a)   (a)
#define __vreinterpret_u32_u64(a)   (a)
#define __vreinterpret_u64_f32(a)   (a)
#define __vreinterpret_u64_s8(a)    (a)
#define __vreinterpret_u64_s16(a)   (a)
#define __vreinterpret_u64_s32(a)   (a)
#define __vreinterpret_u64_s64(a)   (a)
#define __vreinterpret_u64_p8(a)    (a)
#define __vreinterpret_u64_p16(a)   (a)
#define __vreinterpret_u64_u8(a)    (a)
#define __vreinterpret_u64_u16(a)   (a)
#define __vreinterpret_u64_u32(a)   (a)
#define __vreinterpretq_f32_s8(a)   (a)
#define __vreinterpretq_f32_s16(a)  (a)
#define __vreinterpretq_f32_s32(a)  (a)
#define __vreinterpretq_f32_s64(a)  (a)
#define __vreinterpretq_f32_p8(a)   (a)
#define __vreinterpretq_f32_p16(a)  (a)
#define __vreinterpretq_f32_u8(a)   (a)
#define __vreinterpretq_f32_u16(a)  (a)
#define __vreinterpretq_f32_u32(a)  (a)
#define __vreinterpretq_f32_u64(a)  (a)
#define __vreinterpretq_s8_f32(a)   (a)
#define __vreinterpretq_s8_s16(a)   (a)
#define __vreinterpretq_s8_s32(a)   (a)
#define __vreinterpretq_s8_s64(a)   (a)
#define __vreinterpretq_s8_p8(a)    (a)
#define __vreinterpretq_s8_p16(a)   (a)
#define __vreinterpretq_s8_u8(a)    (a)
#define __vreinterpretq_s8_u16(a)   (a)
#define __vreinterpretq_s8_u32(a)   (a)
#define __vreinterpretq_s8_u64(a)   (a)
#define __vreinterpretq_s16_f32(a)  (a)
#define __vreinterpretq_s16_s8(a)   (a)
#define __vreinterpretq_s16_s32(a)  (a)
#define __vreinterpretq_s16_s64(a)  (a)
#define __vreinterpretq_s16_p8(a)   (a)
#define __vreinterpretq_s16_p16(a)  (a)
#define __vreinterpretq_s16_u8(a)   (a)
#define __vreinterpretq_s16_u16(a)  (a)
#define __vreinterpretq_s16_u32(a)  (a)
#define __vreinterpretq_s16_u64(a)  (a)
#define __vreinterpretq_s32_f32(a)  (a)
#define __vreinterpretq_s32_s8(a)   (a)
#define __vreinterpretq_s32_s16(a)  (a)
#define __vreinterpretq_s32_s64(a)  (a)
#define __vreinterpretq_s32_p8(a)   (a)
#define __vreinterpretq_s32_p16(a)  (a)
#define __vreinterpretq_s32_u8(a)   (a)
#define __vreinterpretq_s32_u16(a)  (a)
#define __vreinterpretq_s32_u32(a)  (a)
#define __vreinterpretq_s32_u64(a)  (a)
#define __vreinterpretq_s64_f32(a)  (a)
#define __vreinterpretq_s64_s8(a)   (a)
#define __vreinterpretq_s64_s16(a)  (a)
#define __vreinterpretq_s64_s32(a)  (a)
#define __vreinterpretq_s64_p8(a)   (a)
#define __vreinterpretq_s64_p16(a)  (a)
#define __vreinterpretq_s64_u8(a)   (a)
#define __vreinterpretq_s64_u16(a)  (a)
#define __vreinterpretq_s64_u32(a)  (a)
#define __vreinterpretq_s64_u64(a)  (a)
#define __vreinterpretq_p8_f32(a)   (a)
#define __vreinterpretq_p8_s8(a)    (a)
#define __vreinterpretq_p8_s16(a)   (a)
#define __vreinterpretq_p8_s32(a)   (a)
#define __vreinterpretq_p8_s64(a)   (a)
#define __vreinterpretq_p8_p16(a)   (a)
#define __vreinterpretq_p8_u8(a)    (a)
#define __vreinterpretq_p8_u16(a)   (a)
#define __vreinterpretq_p8_u32(a)   (a)
#define __vreinterpretq_p8_u64(a)   (a)
#define __vreinterpretq_p16_f32(a)  (a)
#define __vreinterpretq_p16_s8(a)   (a)
#define __vreinterpretq_p16_s16(a)  (a)
#define __vreinterpretq_p16_s32(a)  (a)
#define __vreinterpretq_p16_s64(a)  (a)
#define __vreinterpretq_p16_p8(a)   (a)
#define __vreinterpretq_p16_u8(a)   (a)
#define __vreinterpretq_p16_u16(a)  (a)
#define __vreinterpretq_p16_u32(a)  (a)
#define __vreinterpretq_p16_u64(a)  (a)
#define __vreinterpretq_u8_f32(a)   (a)
#define __vreinterpretq_u8_s8(a)    (a)
#define __vreinterpretq_u8_s16(a)   (a)
#define __vreinterpretq_u8_s32(a)   (a)
#define __vreinterpretq_u8_s64(a)   (a)
#define __vreinterpretq_u8_p8(a)    (a)
#define __vreinterpretq_u8_p16(a)   (a)
#define __vreinterpretq_u8_u16(a)   (a)
#define __vreinterpretq_u8_u32(a)   (a)
#define __vreinterpretq_u8_u64(a)   (a)
#define __vreinterpretq_u16_f32(a)  (a)
#define __vreinterpretq_u16_s8(a)   (a)
#define __vreinterpretq_u16_s16(a)  (a)
#define __vreinterpretq_u16_s32(a)  (a)
#define __vreinterpretq_u16_s64(a)  (a)
#define __vreinterpretq_u16_p8(a)   (a)
#define __vreinterpretq_u16_p16(a)  (a)
#define __vreinterpretq_u16_u8(a)   (a)
#define __vreinterpretq_u16_u32(a)  (a)
#define __vreinterpretq_u16_u64(a)  (a)
#define __vreinterpretq_u32_f32(a)  (a)
#define __vreinterpretq_u32_s8(a)   (a)
#define __vreinterpretq_u32_s16(a)  (a)
#define __vreinterpretq_u32_s32(a)  (a)
#define __vreinterpretq_u32_s64(a)  (a)
#define __vreinterpretq_u32_p8(a)   (a)
#define __vreinterpretq_u32_p16(a)  (a)
#define __vreinterpretq_u32_u8(a)   (a)
#define __vreinterpretq_u32_u16(a)  (a)
#define __vreinterpretq_u32_u64(a)  (a)
#define __vreinterpretq_u64_f32(a)  (a)
#define __vreinterpretq_u64_s8(a)   (a)
#define __vreinterpretq_u64_s16(a)  (a)
#define __vreinterpretq_u64_s32(a)  (a)
#define __vreinterpretq_u64_s64(a)  (a)
#define __vreinterpretq_u64_p8(a)   (a)
#define __vreinterpretq_u64_p16(a)  (a)
#define __vreinterpretq_u64_u8(a)   (a)
#define __vreinterpretq_u64_u16(a)  (a)
#define __vreinterpretq_u64_u32(a)  (a)

//  Multiply by scalar
#define __vmul_n_s16(Vd, Rt)        __vmul_lane_s16((Vd), __vmov_n_s16(Rt), 0)
#define __vmul_n_s32(Vd, Rt)        __vmul_lane_s32((Vd), __vmov_n_s32(Rt), 0)
#define __vmul_n_u16(Vd, Rt)        __vmul_lane_u16((Vd), __vmov_n_u16(Rt), 0)
#define __vmul_n_u32(Vd, Rt)        __vmul_lane_u32((Vd), __vmov_n_u32(Rt), 0)
#define __vmulq_n_s16(Vd, Rt)       __vmulq_lane_s16((Vd), __vmov_n_s16(Rt), 0)
#define __vmulq_n_s32(Vd, Rt)       __vmulq_lane_s32((Vd), __vmov_n_s32(Rt), 0)
#define __vmulq_n_u16(Vd, Rt)       __vmulq_lane_u16((Vd), __vmov_n_u16(Rt), 0)
#define __vmulq_n_u32(Vd, Rt)       __vmulq_lane_u32((Vd), __vmov_n_u32(Rt), 0)
#define __vmull_n_s16(Vd, Rt)       __vmull_lane_s16((Vd), __vmov_n_s16(Rt), 0)
#define __vmull_n_s32(Vd, Rt)       __vmull_lane_s32((Vd), __vmov_n_s32(Rt), 0)
#define __vmull_n_u16(Vd, Rt)       __vmull_lane_u16((Vd), __vmov_n_u16(Rt), 0)
#define __vmull_n_u32(Vd, Rt)       __vmull_lane_u32((Vd), __vmov_n_u32(Rt), 0)
#define __vqdmulh_n_s16(Vd, Rt)     __vqdmulh_lane_s16((Vd), __vmov_n_s16(Rt), 0)
#define __vqdmulh_n_s32(Vd, Rt)     __vqdmulh_lane_s32((Vd), __vmov_n_s32(Rt), 0)
#define __vqdmulhq_n_s16(Vd, Rt)    __vqdmulhq_lane_s16((Vd), __vmov_n_s16(Rt), 0)
#define __vqdmulhq_n_s32(Vd, Rt)    __vqdmulhq_lane_s32((Vd), __vmov_n_s32(Rt), 0)
#define __vqdmull_n_s16(Vd, Rt)     __vqdmull_lane_s16((Vd), __vmov_n_s16(Rt), 0)
#define __vqdmull_n_s32(Vd, Rt)     __vqdmull_lane_s32((Vd), __vmov_n_s32(Rt), 0)
#define __vqrdmulh_n_s16(Vd, Rt)    __vqrdmulh_lane_s16((Vd), __vmov_n_s16(Rt), 0)
#define __vqrdmulh_n_s32(Vd, Rt)    __vqrdmulh_lane_s32((Vd), __vmov_n_s32(Rt), 0)
#define __vqrdmulhq_n_s16(Vd, Rt)   __vqrdmulhq_lane_s16((Vd), __vmov_n_s16(Rt), 0)
#define __vqrdmulhq_n_s32(Vd, Rt)   __vqrdmulhq_lane_s32((Vd), __vmov_n_s32(Rt), 0)

//  Multiply by scalar with accumulate
#define __vmla_n_s16(Vd, Vn, Rt)    __vmla_lane_s16((Vd), (Vn), __vmov_n_s16(Rt), 0)
#define __vmla_n_s32(Vd, Vn, Rt)    __vmla_lane_s32((Vd), (Vn), __vmov_n_s32(Rt), 0)
#define __vmla_n_u16(Vd, Vn, Rt)    __vmla_lane_u16((Vd), (Vn), __vmov_n_u16(Rt), 0)
#define __vmla_n_u32(Vd, Vn, Rt)    __vmla_lane_u32((Vd), (Vn), __vmov_n_u32(Rt), 0)
#define __vmlaq_n_s16(Vd, Vn, Rt)   __vmlaq_lane_s16((Vd), (Vn), __vmov_n_s16(Rt), 0)
#define __vmlaq_n_s32(Vd, Vn, Rt)   __vmlaq_lane_s32((Vd), (Vn), __vmov_n_s32(Rt), 0)
#define __vmlaq_n_u16(Vd, Vn, Rt)   __vmlaq_lane_u16((Vd), (Vn), __vmov_n_u16(Rt), 0)
#define __vmlaq_n_u32(Vd, Vn, Rt)   __vmlaq_lane_u32((Vd), (Vn), __vmov_n_u32(Rt), 0)
#define __vmlal_n_s16(Vd, Vn, Rt)   __vmlal_lane_s16((Vd), (Vn), __vmov_n_s16(Rt), 0)
#define __vmlal_n_s32(Vd, Vn, Rt)   __vmlal_lane_s32((Vd), (Vn), __vmov_n_s32(Rt), 0)
#define __vmlal_n_u16(Vd, Vn, Rt)   __vmlal_lane_u16((Vd), (Vn), __vmov_n_u16(Rt), 0)
#define __vmlal_n_u32(Vd, Vn, Rt)   __vmlal_lane_u32((Vd), (Vn), __vmov_n_u32(Rt), 0)
#define __vmls_n_s16(Vd, Vn, Rt)    __vmls_lane_s16((Vd), (Vn), __vmov_n_s16(Rt), 0)
#define __vmls_n_s32(Vd, Vn, Rt)    __vmls_lane_s32((Vd), (Vn), __vmov_n_s32(Rt), 0)
#define __vmls_n_u16(Vd, Vn, Rt)    __vmls_lane_u16((Vd), (Vn), __vmov_n_u16(Rt), 0)
#define __vmls_n_u32(Vd, Vn, Rt)    __vmls_lane_u32((Vd), (Vn), __vmov_n_u32(Rt), 0)
#define __vmlsq_n_s16(Vd, Vn, Rt)   __vmlsq_lane_s16((Vd), (Vn), __vmov_n_s16(Rt), 0)
#define __vmlsq_n_s32(Vd, Vn, Rt)   __vmlsq_lane_s32((Vd), (Vn), __vmov_n_s32(Rt), 0)
#define __vmlsq_n_u16(Vd, Vn, Rt)   __vmlsq_lane_u16((Vd), (Vn), __vmov_n_u16(Rt), 0)
#define __vmlsq_n_u32(Vd, Vn, Rt)   __vmlsq_lane_u32((Vd), (Vn), __vmov_n_u32(Rt), 0)
#define __vmlsl_n_s16(Vd, Vn, Rt)   __vmlsl_lane_s16((Vd), (Vn), __vmov_n_s16(Rt), 0)
#define __vmlsl_n_s32(Vd, Vn, Rt)   __vmlsl_lane_s32((Vd), (Vn), __vmov_n_s32(Rt), 0)
#define __vmlsl_n_u16(Vd, Vn, Rt)   __vmlsl_lane_u16((Vd), (Vn), __vmov_n_u16(Rt), 0)
#define __vmlsl_n_u32(Vd, Vn, Rt)   __vmlsl_lane_u32((Vd), (Vn), __vmov_n_u32(Rt), 0)
#define __vqdmlal_n_s16(Vd, Vn, Rt) __vqdmlal_lane_s16((Vd), (Vn), __vmov_n_s16(Rt), 0)
#define __vqdmlal_n_s32(Vd, Vn, Rt) __vqdmlal_lane_s32((Vd), (Vn), __vmov_n_s32(Rt), 0)
#define __vqdmlsl_n_s16(Vd, Vn, Rt) __vqdmlsl_lane_s16((Vd), (Vn), __vmov_n_s16(Rt), 0)
#define __vqdmlsl_n_s32(Vd, Vn, Rt) __vqdmlsl_lane_s32((Vd), (Vn), __vmov_n_s32(Rt), 0)

//  VDUP.64 (scalar)
#define __vdup_lane_s64(Dn, lane)   (__static_assert((lane) == 0, "invalid lane index"), (Dn))
#define __vdup_lane_u64(Dn, lane)   (__static_assert((lane) == 0, "invalid lane index"), (Dn))

//  VDUP.W.64 (scalar)
#define __vdupq_lane_s64(Dn, lane)  (__static_assert((lane) == 0, "invalid lane index"), vcombine_s64((Dn), (Dn)))
#define __vdupq_lane_u64(Dn, lane)  (__static_assert((lane) == 0, "invalid lane index"), vcombine_u64((Dn), (Dn)))

#if !defined(_ARM_ISO_COMPATIBLE_INTRINSIC_NAMES)

#define aesd_p8                     __aesd_p8
#define aesd_s8                     __aesd_s8
#define aesd_u8                     __aesd_u8
#define aese_p8                     __aese_p8
#define aese_s8                     __aese_s8
#define aese_u8                     __aese_u8
#define aesimc_p8                   __aesimc_p8
#define aesimc_s8                   __aesimc_s8
#define aesimc_u8                   __aesimc_u8
#define aesmc_p8                    __aesmc_p8
#define aesmc_s8                    __aesmc_s8
#define aesmc_u8                    __aesmc_u8
#define sha1h_f32                   __sha1h_f32
#define sha1h_s32                   __sha1h_s32
#define sha1h_u32                   __sha1h_u32
#define sha1su1_f32                 __sha1su1_f32
#define sha1su1_s32                 __sha1su1_s32
#define sha1su1_u32                 __sha1su1_u32
#define sha256su0_f32               __sha256su0_f32
#define sha256su0_s32               __sha256su0_s32
#define sha256su0_u32               __sha256su0_u32
#define sha1c_f32                   __sha1c_f32
#define sha1c_s32                   __sha1c_s32
#define sha1c_u32                   __sha1c_u32
#define sha1m_f32                   __sha1m_f32
#define sha1m_s32                   __sha1m_s32
#define sha1m_u32                   __sha1m_u32
#define sha1p_f32                   __sha1p_f32
#define sha1p_s32                   __sha1p_s32
#define sha1p_u32                   __sha1p_u32
#define sha1su0_f32                 __sha1su0_f32
#define sha1su0_s32                 __sha1su0_s32
#define sha1su0_u32                 __sha1su0_u32
#define sha256h_f32                 __sha256h_f32
#define sha256h_s32                 __sha256h_s32
#define sha256h_u32                 __sha256h_u32
#define sha256h2_f32                __sha256h2_f32
#define sha256h2_s32                __sha256h2_s32
#define sha256h2_u32                __sha256h2_u32
#define sha256su1_f32               __sha256su1_f32
#define sha256su1_s32               __sha256su1_s32
#define sha256su1_u32               __sha256su1_u32
#define vaba_s16                    __vaba_s16
#define vaba_s32                    __vaba_s32
#define vaba_s8                     __vaba_s8
#define vaba_u16                    __vaba_u16
#define vaba_u32                    __vaba_u32
#define vaba_u8                     __vaba_u8
#define vabal_s16                   __vabal_s16
#define vabal_s32                   __vabal_s32
#define vabal_s8                    __vabal_s8
#define vabal_u16                   __vabal_u16
#define vabal_u32                   __vabal_u32
#define vabal_u8                    __vabal_u8
#define vabaq_s16                   __vabaq_s16
#define vabaq_s32                   __vabaq_s32
#define vabaq_s8                    __vabaq_s8
#define vabaq_u16                   __vabaq_u16
#define vabaq_u32                   __vabaq_u32
#define vabaq_u8                    __vabaq_u8
#define vabd_f32                    __vabd_f32
#define vabdq_f32                   __vabdq_f32
#define vabd_s16                    __vabd_s16
#define vabd_s32                    __vabd_s32
#define vabd_s8                     __vabd_s8
#define vabd_u16                    __vabd_u16
#define vabd_u32                    __vabd_u32
#define vabd_u8                     __vabd_u8
#define vabdl_s16                   __vabdl_s16
#define vabdl_s32                   __vabdl_s32
#define vabdl_s8                    __vabdl_s8
#define vabdl_u16                   __vabdl_u16
#define vabdl_u32                   __vabdl_u32
#define vabdl_u8                    __vabdl_u8
#define vabdq_s16                   __vabdq_s16
#define vabdq_s32                   __vabdq_s32
#define vabdq_s8                    __vabdq_s8
#define vabdq_u16                   __vabdq_u16
#define vabdq_u32                   __vabdq_u32
#define vabdq_u8                    __vabdq_u8
#define vabs_f32                    __vabs_f32
#define vabs_s16                    __vabs_s16
#define vabs_s32                    __vabs_s32
#define vabs_s8                     __vabs_s8
#define vneg_f32                    __vneg_f32
#define vneg_s16                    __vneg_s16
#define vneg_s32                    __vneg_s32
#define vneg_s8                     __vneg_s8
#define vabsq_f32                   __vabsq_f32
#define vabsq_s16                   __vabsq_s16
#define vabsq_s32                   __vabsq_s32
#define vabsq_s8                    __vabsq_s8
#define vnegq_f32                   __vnegq_f32
#define vnegq_s16                   __vnegq_s16
#define vnegq_s32                   __vnegq_s32
#define vnegq_s8                    __vnegq_s8
#define vacge_f32                   __vacge_f32
#define vacgt_f32                   __vacgt_f32
#define vacle_f32                   __vacle_f32
#define vaclt_f32                   __vaclt_f32
#define vacgeq_f32                  __vacgeq_f32
#define vacgtq_f32                  __vacgtq_f32
#define vacleq_f32                  __vacleq_f32
#define vacltq_f32                  __vacltq_f32
#define vadd_f32                    __vadd_f32
#define vadd_s16                    __vadd_s16
#define vadd_s32                    __vadd_s32
#define vadd_s64                    __vadd_s64
#define vadd_s8                     __vadd_s8
#define vadd_u16                    __vadd_u16
#define vadd_u32                    __vadd_u32
#define vadd_u64                    __vadd_u64
#define vadd_u8                     __vadd_u8
#define vaddq_f32                   __vaddq_f32
#define vaddq_s16                   __vaddq_s16
#define vaddq_s32                   __vaddq_s32
#define vaddq_s64                   __vaddq_s64
#define vaddq_s8                    __vaddq_s8
#define vaddq_u16                   __vaddq_u16
#define vaddq_u32                   __vaddq_u32
#define vaddq_u64                   __vaddq_u64
#define vaddq_u8                    __vaddq_u8
#define vaddhn_s16                  __vaddhn_s16
#define vaddhn_s32                  __vaddhn_s32
#define vaddhn_s64                  __vaddhn_s64
#define vaddhn_u16                  __vaddhn_u16
#define vaddhn_u32                  __vaddhn_u32
#define vaddhn_u64                  __vaddhn_u64
#define vraddhn_s16                 __vraddhn_s16
#define vraddhn_s32                 __vraddhn_s32
#define vraddhn_s64                 __vraddhn_s64
#define vraddhn_u16                 __vraddhn_u16
#define vraddhn_u32                 __vraddhn_u32
#define vraddhn_u64                 __vraddhn_u64
#define vaddl_s16                   __vaddl_s16
#define vaddl_s32                   __vaddl_s32
#define vaddl_s8                    __vaddl_s8
#define vaddl_u16                   __vaddl_u16
#define vaddl_u32                   __vaddl_u32
#define vaddl_u8                    __vaddl_u8
#define vaddw_s16                   __vaddw_s16
#define vaddw_s32                   __vaddw_s32
#define vaddw_s8                    __vaddw_s8
#define vaddw_u16                   __vaddw_u16
#define vaddw_u32                   __vaddw_u32
#define vaddw_u8                    __vaddw_u8
#define vand_s16                    __vand_s16
#define vand_s32                    __vand_s32
#define vand_s64                    __vand_s64
#define vand_s8                     __vand_s8
#define vand_u16                    __vand_u16
#define vand_u32                    __vand_u32
#define vand_u64                    __vand_u64
#define vand_u8                     __vand_u8
#define vorr_s16                    __vorr_s16
#define vorr_s32                    __vorr_s32
#define vorr_s64                    __vorr_s64
#define vorr_s8                     __vorr_s8
#define vorr_u16                    __vorr_u16
#define vorr_u32                    __vorr_u32
#define vorr_u64                    __vorr_u64
#define vorr_u8                     __vorr_u8
#define vandq_s16                   __vandq_s16
#define vandq_s32                   __vandq_s32
#define vandq_s64                   __vandq_s64
#define vandq_s8                    __vandq_s8
#define vandq_u16                   __vandq_u16
#define vandq_u32                   __vandq_u32
#define vandq_u64                   __vandq_u64
#define vandq_u8                    __vandq_u8
#define vorrq_s16                   __vorrq_s16
#define vorrq_s32                   __vorrq_s32
#define vorrq_s64                   __vorrq_s64
#define vorrq_s8                    __vorrq_s8
#define vorrq_u16                   __vorrq_u16
#define vorrq_u32                   __vorrq_u32
#define vorrq_u64                   __vorrq_u64
#define vorrq_u8                    __vorrq_u8
#define vbif_f32                    __vbif_f32
#define vbif_p16                    __vbif_p16
#define vbif_p8                     __vbif_p8
#define vbif_s16                    __vbif_s16
#define vbif_s32                    __vbif_s32
#define vbif_s64                    __vbif_s64
#define vbif_s8                     __vbif_s8
#define vbif_u16                    __vbif_u16
#define vbif_u32                    __vbif_u32
#define vbif_u64                    __vbif_u64
#define vbif_u8                     __vbif_u8
#define vbit_f32                    __vbit_f32
#define vbit_p16                    __vbit_p16
#define vbit_p8                     __vbit_p8
#define vbit_s16                    __vbit_s16
#define vbit_s32                    __vbit_s32
#define vbit_s64                    __vbit_s64
#define vbit_s8                     __vbit_s8
#define vbit_u16                    __vbit_u16
#define vbit_u32                    __vbit_u32
#define vbit_u64                    __vbit_u64
#define vbit_u8                     __vbit_u8
#define vbsl_f32                    __vbsl_f32
#define vbsl_p16                    __vbsl_p16
#define vbsl_p8                     __vbsl_p8
#define vbsl_s16                    __vbsl_s16
#define vbsl_s32                    __vbsl_s32
#define vbsl_s64                    __vbsl_s64
#define vbsl_s8                     __vbsl_s8
#define vbsl_u16                    __vbsl_u16
#define vbsl_u32                    __vbsl_u32
#define vbsl_u64                    __vbsl_u64
#define vbsl_u8                     __vbsl_u8
#define vbifq_f32                   __vbifq_f32
#define vbifq_p16                   __vbifq_p16
#define vbifq_p8                    __vbifq_p8
#define vbifq_s16                   __vbifq_s16
#define vbifq_s32                   __vbifq_s32
#define vbifq_s64                   __vbifq_s64
#define vbifq_s8                    __vbifq_s8
#define vbifq_u16                   __vbifq_u16
#define vbifq_u32                   __vbifq_u32
#define vbifq_u64                   __vbifq_u64
#define vbifq_u8                    __vbifq_u8
#define vbitq_f32                   __vbitq_f32
#define vbitq_p16                   __vbitq_p16
#define vbitq_p8                    __vbitq_p8
#define vbitq_s16                   __vbitq_s16
#define vbitq_s32                   __vbitq_s32
#define vbitq_s64                   __vbitq_s64
#define vbitq_s8                    __vbitq_s8
#define vbitq_u16                   __vbitq_u16
#define vbitq_u32                   __vbitq_u32
#define vbitq_u64                   __vbitq_u64
#define vbitq_u8                    __vbitq_u8
#define vbslq_f32                   __vbslq_f32
#define vbslq_p16                   __vbslq_p16
#define vbslq_p8                    __vbslq_p8
#define vbslq_s16                   __vbslq_s16
#define vbslq_s32                   __vbslq_s32
#define vbslq_s64                   __vbslq_s64
#define vbslq_s8                    __vbslq_s8
#define vbslq_u16                   __vbslq_u16
#define vbslq_u32                   __vbslq_u32
#define vbslq_u64                   __vbslq_u64
#define vbslq_u8                    __vbslq_u8
#define vceq_z_f32_ex               __vceq_z_f32_ex
#define vceq_z_s16_ex               __vceq_z_s16_ex
#define vceq_z_s32_ex               __vceq_z_s32_ex
#define vceq_z_s8_ex                __vceq_z_s8_ex
#define vceq_z_u16_ex               __vceq_z_u16_ex
#define vceq_z_u32_ex               __vceq_z_u32_ex
#define vceq_z_u8_ex                __vceq_z_u8_ex
#define vceqq_z_f32_ex              __vceqq_z_f32_ex
#define vceqq_z_s16_ex              __vceqq_z_s16_ex
#define vceqq_z_s32_ex              __vceqq_z_s32_ex
#define vceqq_z_s8_ex               __vceqq_z_s8_ex
#define vceqq_z_u16_ex              __vceqq_z_u16_ex
#define vceqq_z_u32_ex              __vceqq_z_u32_ex
#define vceqq_z_u8_ex               __vceqq_z_u8_ex
#define vceq_f32                    __vceq_f32
#define vceq_p8                     __vceq_p8
#define vceq_s16                    __vceq_s16
#define vceq_s32                    __vceq_s32
#define vceq_s8                     __vceq_s8
#define vceq_u16                    __vceq_u16
#define vceq_u32                    __vceq_u32
#define vceq_u8                     __vceq_u8
#define vceqq_f32                   __vceqq_f32
#define vceqq_p8                    __vceqq_p8
#define vceqq_s16                   __vceqq_s16
#define vceqq_s32                   __vceqq_s32
#define vceqq_s8                    __vceqq_s8
#define vceqq_u16                   __vceqq_u16
#define vceqq_u32                   __vceqq_u32
#define vceqq_u8                    __vceqq_u8
#define vcge_z_f32_ex               __vcge_z_f32_ex
#define vcge_z_s16_ex               __vcge_z_s16_ex
#define vcge_z_s32_ex               __vcge_z_s32_ex
#define vcge_z_s8_ex                __vcge_z_s8_ex
#define vcgeq_z_f32_ex              __vcgeq_z_f32_ex
#define vcgeq_z_s16_ex              __vcgeq_z_s16_ex
#define vcgeq_z_s32_ex              __vcgeq_z_s32_ex
#define vcgeq_z_s8_ex               __vcgeq_z_s8_ex
#define vcge_f32                    __vcge_f32
#define vcge_s16                    __vcge_s16
#define vcge_s32                    __vcge_s32
#define vcge_s8                     __vcge_s8
#define vcge_u16                    __vcge_u16
#define vcge_u32                    __vcge_u32
#define vcge_u8                     __vcge_u8
#define vcle_f32                    __vcle_f32
#define vcle_s16                    __vcle_s16
#define vcle_s32                    __vcle_s32
#define vcle_s8                     __vcle_s8
#define vcle_u16                    __vcle_u16
#define vcle_u32                    __vcle_u32
#define vcle_u8                     __vcle_u8
#define vcgeq_f32                   __vcgeq_f32
#define vcgeq_s16                   __vcgeq_s16
#define vcgeq_s32                   __vcgeq_s32
#define vcgeq_s8                    __vcgeq_s8
#define vcgeq_u16                   __vcgeq_u16
#define vcgeq_u32                   __vcgeq_u32
#define vcgeq_u8                    __vcgeq_u8
#define vcleq_f32                   __vcleq_f32
#define vcleq_s16                   __vcleq_s16
#define vcleq_s32                   __vcleq_s32
#define vcleq_s8                    __vcleq_s8
#define vcleq_u16                   __vcleq_u16
#define vcleq_u32                   __vcleq_u32
#define vcleq_u8                    __vcleq_u8
#define vcgt_z_f32_ex               __vcgt_z_f32_ex
#define vcgt_z_s16_ex               __vcgt_z_s16_ex
#define vcgt_z_s32_ex               __vcgt_z_s32_ex
#define vcgt_z_s8_ex                __vcgt_z_s8_ex
#define vcgtq_z_f32_ex              __vcgtq_z_f32_ex
#define vcgtq_z_s16_ex              __vcgtq_z_s16_ex
#define vcgtq_z_s32_ex              __vcgtq_z_s32_ex
#define vcgtq_z_s8_ex               __vcgtq_z_s8_ex
#define vcgt_f32                    __vcgt_f32
#define vcgt_s16                    __vcgt_s16
#define vcgt_s32                    __vcgt_s32
#define vcgt_s8                     __vcgt_s8
#define vcgt_u16                    __vcgt_u16
#define vcgt_u32                    __vcgt_u32
#define vcgt_u8                     __vcgt_u8
#define vclt_f32                    __vclt_f32
#define vclt_s16                    __vclt_s16
#define vclt_s32                    __vclt_s32
#define vclt_s8                     __vclt_s8
#define vclt_u16                    __vclt_u16
#define vclt_u32                    __vclt_u32
#define vclt_u8                     __vclt_u8
#define vcgtq_f32                   __vcgtq_f32
#define vcgtq_s16                   __vcgtq_s16
#define vcgtq_s32                   __vcgtq_s32
#define vcgtq_s8                    __vcgtq_s8
#define vcgtq_u16                   __vcgtq_u16
#define vcgtq_u32                   __vcgtq_u32
#define vcgtq_u8                    __vcgtq_u8
#define vcltq_f32                   __vcltq_f32
#define vcltq_s16                   __vcltq_s16
#define vcltq_s32                   __vcltq_s32
#define vcltq_s8                    __vcltq_s8
#define vcltq_u16                   __vcltq_u16
#define vcltq_u32                   __vcltq_u32
#define vcltq_u8                    __vcltq_u8
#define vcle_z_f32_ex               __vcle_z_f32_ex
#define vcle_z_s16_ex               __vcle_z_s16_ex
#define vcle_z_s32_ex               __vcle_z_s32_ex
#define vcle_z_s8_ex                __vcle_z_s8_ex
#define vcleq_z_f32_ex              __vcleq_z_f32_ex
#define vcleq_z_s16_ex              __vcleq_z_s16_ex
#define vcleq_z_s32_ex              __vcleq_z_s32_ex
#define vcleq_z_s8_ex               __vcleq_z_s8_ex
#define vcls_s16                    __vcls_s16
#define vcls_s32                    __vcls_s32
#define vcls_s8                     __vcls_s8
#define vclz_s16                    __vclz_s16
#define vclz_s32                    __vclz_s32
#define vclz_s8                     __vclz_s8
#define vclz_u16                    __vclz_u16
#define vclz_u32                    __vclz_u32
#define vclz_u8                     __vclz_u8
#define vclsq_s16                   __vclsq_s16
#define vclsq_s32                   __vclsq_s32
#define vclsq_s8                    __vclsq_s8
#define vclzq_s16                   __vclzq_s16
#define vclzq_s32                   __vclzq_s32
#define vclzq_s8                    __vclzq_s8
#define vclzq_u16                   __vclzq_u16
#define vclzq_u32                   __vclzq_u32
#define vclzq_u8                    __vclzq_u8
#define vclt_z_f32_ex               __vclt_z_f32_ex
#define vclt_z_s16_ex               __vclt_z_s16_ex
#define vclt_z_s32_ex               __vclt_z_s32_ex
#define vclt_z_s8_ex                __vclt_z_s8_ex
#define vcltq_z_f32_ex              __vcltq_z_f32_ex
#define vcltq_z_s16_ex              __vcltq_z_s16_ex
#define vcltq_z_s32_ex              __vcltq_z_s32_ex
#define vcltq_z_s8_ex               __vcltq_z_s8_ex
#define vcnt_p8                     __vcnt_p8
#define vcnt_s8                     __vcnt_s8
#define vcnt_u8                     __vcnt_u8
#define vcntq_p8                    __vcntq_p8
#define vcntq_s8                    __vcntq_s8
#define vcntq_u8                    __vcntq_u8
#define vcombine_f32                __vcombine_f32
#define vcombine_p16                __vcombine_p16
#define vcombine_p8                 __vcombine_p8
#define vcombine_s16                __vcombine_s16
#define vcombine_s32                __vcombine_s32
#define vcombine_s64                __vcombine_s64
#define vcombine_s8                 __vcombine_s8
#define vcombine_u16                __vcombine_u16
#define vcombine_u32                __vcombine_u32
#define vcombine_u64                __vcombine_u64
#define vcombine_u8                 __vcombine_u8
#define vcreate_f32                 __vcreate_f32
#define vcreate_p16                 __vcreate_p16
#define vcreate_p8                  __vcreate_p8
#define vcreate_s16                 __vcreate_s16
#define vcreate_s32                 __vcreate_s32
#define vcreate_s64                 __vcreate_s64
#define vcreate_s8                  __vcreate_s8
#define vcreate_u16                 __vcreate_u16
#define vcreate_u32                 __vcreate_u32
#define vcreate_u64                 __vcreate_u64
#define vcreate_u8                  __vcreate_u8
#define vcvt_n_f32_s32              __vcvt_n_f32_s32
#define vcvt_n_f32_u32              __vcvt_n_f32_u32
#define vcvt_n_s32_f32              __vcvt_n_s32_f32
#define vcvt_n_u32_f32              __vcvt_n_u32_f32
#define vcvtq_n_f32_s32             __vcvtq_n_f32_s32
#define vcvtq_n_f32_u32             __vcvtq_n_f32_u32
#define vcvtq_n_s32_f32             __vcvtq_n_s32_f32
#define vcvtq_n_u32_f32             __vcvtq_n_u32_f32
#define vcvta_s32_f32               __vcvta_s32_f32
#define vcvta_u32_f32               __vcvta_u32_f32
#define vcvtm_s32_f32               __vcvtm_s32_f32
#define vcvtm_u32_f32               __vcvtm_u32_f32
#define vcvtn_s32_f32               __vcvtn_s32_f32
#define vcvtn_u32_f32               __vcvtn_u32_f32
#define vcvtp_s32_f32               __vcvtp_s32_f32
#define vcvtp_u32_f32               __vcvtp_u32_f32
#define vcvtaq_s32_f32              __vcvtaq_s32_f32
#define vcvtaq_u32_f32              __vcvtaq_u32_f32
#define vcvtmq_s32_f32              __vcvtmq_s32_f32
#define vcvtmq_u32_f32              __vcvtmq_u32_f32
#define vcvtnq_s32_f32              __vcvtnq_s32_f32
#define vcvtnq_u32_f32              __vcvtnq_u32_f32
#define vcvtpq_s32_f32              __vcvtpq_s32_f32
#define vcvtpq_u32_f32              __vcvtpq_u32_f32
#define vcvt_f32_s32                __vcvt_f32_s32
#define vcvt_f32_u32                __vcvt_f32_u32
#define vcvt_s32_f32                __vcvt_s32_f32
#define vcvt_u32_f32                __vcvt_u32_f32
#define vcvtq_f32_s32               __vcvtq_f32_s32
#define vcvtq_f32_u32               __vcvtq_f32_u32
#define vcvtq_s32_f32               __vcvtq_s32_f32
#define vcvtq_u32_f32               __vcvtq_u32_f32
#define vdup_lane_f32               __vdup_lane_f32
#define vdup_lane_p16               __vdup_lane_p16
#define vdup_lane_p8                __vdup_lane_p8
#define vdup_lane_s16               __vdup_lane_s16
#define vdup_lane_s32               __vdup_lane_s32
#define vdup_lane_s8                __vdup_lane_s8
#define vdup_lane_u16               __vdup_lane_u16
#define vdup_lane_u32               __vdup_lane_u32
#define vdup_lane_u8                __vdup_lane_u8
#define vdupq_lane_f32              __vdupq_lane_f32
#define vdupq_lane_p16              __vdupq_lane_p16
#define vdupq_lane_p8               __vdupq_lane_p8
#define vdupq_lane_s16              __vdupq_lane_s16
#define vdupq_lane_s32              __vdupq_lane_s32
#define vdupq_lane_s8               __vdupq_lane_s8
#define vdupq_lane_u16              __vdupq_lane_u16
#define vdupq_lane_u32              __vdupq_lane_u32
#define vdupq_lane_u8               __vdupq_lane_u8
#define vdup_n_f32                  __vdup_n_f32
#define vmov_n_f32                  __vmov_n_f32
#define vdup_n_p16                  __vdup_n_p16
#define vdup_n_p8                   __vdup_n_p8
#define vdup_n_s16                  __vdup_n_s16
#define vdup_n_s32                  __vdup_n_s32
#define vdup_n_s8                   __vdup_n_s8
#define vdup_n_u16                  __vdup_n_u16
#define vdup_n_u32                  __vdup_n_u32
#define vdup_n_u8                   __vdup_n_u8
#define vmov_n_p16                  __vmov_n_p16
#define vmov_n_p8                   __vmov_n_p8
#define vmov_n_s16                  __vmov_n_s16
#define vmov_n_s32                  __vmov_n_s32
#define vmov_n_s8                   __vmov_n_s8
#define vmov_n_u16                  __vmov_n_u16
#define vmov_n_u32                  __vmov_n_u32
#define vmov_n_u8                   __vmov_n_u8
#define vdupq_n_f32                 __vdupq_n_f32
#define vmovq_n_f32                 __vmovq_n_f32
#define vdupq_n_p16                 __vdupq_n_p16
#define vdupq_n_p8                  __vdupq_n_p8
#define vdupq_n_s16                 __vdupq_n_s16
#define vdupq_n_s32                 __vdupq_n_s32
#define vdupq_n_s8                  __vdupq_n_s8
#define vdupq_n_u16                 __vdupq_n_u16
#define vdupq_n_u32                 __vdupq_n_u32
#define vdupq_n_u8                  __vdupq_n_u8
#define vmovq_n_p16                 __vmovq_n_p16
#define vmovq_n_p8                  __vmovq_n_p8
#define vmovq_n_s16                 __vmovq_n_s16
#define vmovq_n_s32                 __vmovq_n_s32
#define vmovq_n_s8                  __vmovq_n_s8
#define vmovq_n_u16                 __vmovq_n_u16
#define vmovq_n_u32                 __vmovq_n_u32
#define vmovq_n_u8                  __vmovq_n_u8
#define vdup_n_s64                  __vdup_n_s64
#define vdup_n_u64                  __vdup_n_u64
#define vmov_n_s64                  __vmov_n_s64
#define vmov_n_u64                  __vmov_n_u64
#define vdupq_n_s64                 __vdupq_n_s64
#define vdupq_n_u64                 __vdupq_n_u64
#define vmovq_n_s64                 __vmovq_n_s64
#define vmovq_n_u64                 __vmovq_n_u64
#define vbic_s16                    __vbic_s16
#define vbic_s32                    __vbic_s32
#define vbic_s64                    __vbic_s64
#define vbic_s8                     __vbic_s8
#define vbic_u16                    __vbic_u16
#define vbic_u32                    __vbic_u32
#define vbic_u64                    __vbic_u64
#define vbic_u8                     __vbic_u8
#define veor_s16                    __veor_s16
#define veor_s32                    __veor_s32
#define veor_s64                    __veor_s64
#define veor_s8                     __veor_s8
#define veor_u16                    __veor_u16
#define veor_u32                    __veor_u32
#define veor_u64                    __veor_u64
#define veor_u8                     __veor_u8
#define vorn_s16                    __vorn_s16
#define vorn_s32                    __vorn_s32
#define vorn_s64                    __vorn_s64
#define vorn_s8                     __vorn_s8
#define vorn_u16                    __vorn_u16
#define vorn_u32                    __vorn_u32
#define vorn_u64                    __vorn_u64
#define vorn_u8                     __vorn_u8
#define vbicq_s16                   __vbicq_s16
#define vbicq_s32                   __vbicq_s32
#define vbicq_s64                   __vbicq_s64
#define vbicq_s8                    __vbicq_s8
#define vbicq_u16                   __vbicq_u16
#define vbicq_u32                   __vbicq_u32
#define vbicq_u64                   __vbicq_u64
#define vbicq_u8                    __vbicq_u8
#define veorq_s16                   __veorq_s16
#define veorq_s32                   __veorq_s32
#define veorq_s64                   __veorq_s64
#define veorq_s8                    __veorq_s8
#define veorq_u16                   __veorq_u16
#define veorq_u32                   __veorq_u32
#define veorq_u64                   __veorq_u64
#define veorq_u8                    __veorq_u8
#define vornq_s16                   __vornq_s16
#define vornq_s32                   __vornq_s32
#define vornq_s64                   __vornq_s64
#define vornq_s8                    __vornq_s8
#define vornq_u16                   __vornq_u16
#define vornq_u32                   __vornq_u32
#define vornq_u64                   __vornq_u64
#define vornq_u8                    __vornq_u8
#define vext_f32                    __vext_f32
#define vext_p16                    __vext_p16
#define vext_p8                     __vext_p8
#define vext_s16                    __vext_s16
#define vext_s32                    __vext_s32
#define vext_s64                    __vext_s64
#define vext_s8                     __vext_s8
#define vext_u16                    __vext_u16
#define vext_u32                    __vext_u32
#define vext_u64                    __vext_u64
#define vext_u8                     __vext_u8
#define vextq_f32                   __vextq_f32
#define vextq_p16                   __vextq_p16
#define vextq_p8                    __vextq_p8
#define vextq_s16                   __vextq_s16
#define vextq_s32                   __vextq_s32
#define vextq_s64                   __vextq_s64
#define vextq_s8                    __vextq_s8
#define vextq_u16                   __vextq_u16
#define vextq_u32                   __vextq_u32
#define vextq_u64                   __vextq_u64
#define vextq_u8                    __vextq_u8
#define vget_high_f32               __vget_high_f32
#define vget_high_p16               __vget_high_p16
#define vget_high_p8                __vget_high_p8
#define vget_high_s16               __vget_high_s16
#define vget_high_s32               __vget_high_s32
#define vget_high_s64               __vget_high_s64
#define vget_high_s8                __vget_high_s8
#define vget_high_u16               __vget_high_u16
#define vget_high_u32               __vget_high_u32
#define vget_high_u64               __vget_high_u64
#define vget_high_u8                __vget_high_u8
#define vget_low_f32                __vget_low_f32
#define vget_low_p16                __vget_low_p16
#define vget_low_p8                 __vget_low_p8
#define vget_low_s16                __vget_low_s16
#define vget_low_s32                __vget_low_s32
#define vget_low_s64                __vget_low_s64
#define vget_low_s8                 __vget_low_s8
#define vget_low_u16                __vget_low_u16
#define vget_low_u32                __vget_low_u32
#define vget_low_u64                __vget_low_u64
#define vget_low_u8                 __vget_low_u8
#define vhadd_s16                   __vhadd_s16
#define vhadd_s32                   __vhadd_s32
#define vhadd_s8                    __vhadd_s8
#define vhadd_u16                   __vhadd_u16
#define vhadd_u32                   __vhadd_u32
#define vhadd_u8                    __vhadd_u8
#define vhsub_s16                   __vhsub_s16
#define vhsub_s32                   __vhsub_s32
#define vhsub_s8                    __vhsub_s8
#define vhsub_u16                   __vhsub_u16
#define vhsub_u32                   __vhsub_u32
#define vhsub_u8                    __vhsub_u8
#define vrhadd_s16                  __vrhadd_s16
#define vrhadd_s32                  __vrhadd_s32
#define vrhadd_s8                   __vrhadd_s8
#define vrhadd_u16                  __vrhadd_u16
#define vrhadd_u32                  __vrhadd_u32
#define vrhadd_u8                   __vrhadd_u8
#define vhaddq_s16                  __vhaddq_s16
#define vhaddq_s32                  __vhaddq_s32
#define vhaddq_s8                   __vhaddq_s8
#define vhaddq_u16                  __vhaddq_u16
#define vhaddq_u32                  __vhaddq_u32
#define vhaddq_u8                   __vhaddq_u8
#define vhsubq_s16                  __vhsubq_s16
#define vhsubq_s32                  __vhsubq_s32
#define vhsubq_s8                   __vhsubq_s8
#define vhsubq_u16                  __vhsubq_u16
#define vhsubq_u32                  __vhsubq_u32
#define vhsubq_u8                   __vhsubq_u8
#define vrhaddq_s16                 __vrhaddq_s16
#define vrhaddq_s32                 __vrhaddq_s32
#define vrhaddq_s8                  __vrhaddq_s8
#define vrhaddq_u16                 __vrhaddq_u16
#define vrhaddq_u32                 __vrhaddq_u32
#define vrhaddq_u8                  __vrhaddq_u8
#define vld1_f32                    __vld1_f32
#define vld1_p16                    __vld1_p16
#define vld1_p8                     __vld1_p8
#define vld1_s16                    __vld1_s16
#define vld1_s32                    __vld1_s32
#define vld1_s64                    __vld1_s64
#define vld1_s8                     __vld1_s8
#define vld1_u16                    __vld1_u16
#define vld1_u32                    __vld1_u32
#define vld1_u64                    __vld1_u64
#define vld1_u8                     __vld1_u8
#define vld1_f32_ex                 __vld1_f32_ex
#define vld1_p16_ex                 __vld1_p16_ex
#define vld1_p8_ex                  __vld1_p8_ex
#define vld1_s16_ex                 __vld1_s16_ex
#define vld1_s32_ex                 __vld1_s32_ex
#define vld1_s64_ex                 __vld1_s64_ex
#define vld1_s8_ex                  __vld1_s8_ex
#define vld1_u16_ex                 __vld1_u16_ex
#define vld1_u32_ex                 __vld1_u32_ex
#define vld1_u64_ex                 __vld1_u64_ex
#define vld1_u8_ex                  __vld1_u8_ex
#define vld1q_f32                   __vld1q_f32
#define vld1q_p16                   __vld1q_p16
#define vld1q_p8                    __vld1q_p8
#define vld1q_s16                   __vld1q_s16
#define vld1q_s32                   __vld1q_s32
#define vld1q_s64                   __vld1q_s64
#define vld1q_s8                    __vld1q_s8
#define vld1q_u16                   __vld1q_u16
#define vld1q_u32                   __vld1q_u32
#define vld1q_u64                   __vld1q_u64
#define vld1q_u8                    __vld1q_u8
#define vld1q_f32_ex                __vld1q_f32_ex
#define vld1q_p16_ex                __vld1q_p16_ex
#define vld1q_p8_ex                 __vld1q_p8_ex
#define vld1q_s16_ex                __vld1q_s16_ex
#define vld1q_s32_ex                __vld1q_s32_ex
#define vld1q_s64_ex                __vld1q_s64_ex
#define vld1q_s8_ex                 __vld1q_s8_ex
#define vld1q_u16_ex                __vld1q_u16_ex
#define vld1q_u32_ex                __vld1q_u32_ex
#define vld1q_u64_ex                __vld1q_u64_ex
#define vld1q_u8_ex                 __vld1q_u8_ex
#define vld1_dup_f32                __vld1_dup_f32
#define vld1_dup_p16                __vld1_dup_p16
#define vld1_dup_p8                 __vld1_dup_p8
#define vld1_dup_s16                __vld1_dup_s16
#define vld1_dup_s32                __vld1_dup_s32
#define vld1_dup_s8                 __vld1_dup_s8
#define vld1_dup_u16                __vld1_dup_u16
#define vld1_dup_u32                __vld1_dup_u32
#define vld1_dup_u8                 __vld1_dup_u8
#define vld1q_dup_f32               __vld1q_dup_f32
#define vld1q_dup_p16               __vld1q_dup_p16
#define vld1q_dup_p8                __vld1q_dup_p8
#define vld1q_dup_s16               __vld1q_dup_s16
#define vld1q_dup_s32               __vld1q_dup_s32
#define vld1q_dup_s8                __vld1q_dup_s8
#define vld1q_dup_u16               __vld1q_dup_u16
#define vld1q_dup_u32               __vld1q_dup_u32
#define vld1q_dup_u8                __vld1q_dup_u8
#define vld1_dup_f32_ex             __vld1_dup_f32_ex
#define vld1_dup_p16_ex             __vld1_dup_p16_ex
#define vld1_dup_s16_ex             __vld1_dup_s16_ex
#define vld1_dup_s32_ex             __vld1_dup_s32_ex
#define vld1_dup_u16_ex             __vld1_dup_u16_ex
#define vld1_dup_u32_ex             __vld1_dup_u32_ex
#define vld1q_dup_f32_ex            __vld1q_dup_f32_ex
#define vld1q_dup_p16_ex            __vld1q_dup_p16_ex
#define vld1q_dup_s16_ex            __vld1q_dup_s16_ex
#define vld1q_dup_s32_ex            __vld1q_dup_s32_ex
#define vld1q_dup_u16_ex            __vld1q_dup_u16_ex
#define vld1q_dup_u32_ex            __vld1q_dup_u32_ex
#define vld1_lane_f32               __vld1_lane_f32
#define vld1_lane_p16               __vld1_lane_p16
#define vld1_lane_p8                __vld1_lane_p8
#define vld1_lane_s16               __vld1_lane_s16
#define vld1_lane_s32               __vld1_lane_s32
#define vld1_lane_s8                __vld1_lane_s8
#define vld1_lane_u16               __vld1_lane_u16
#define vld1_lane_u32               __vld1_lane_u32
#define vld1_lane_u8                __vld1_lane_u8
#define vld1q_lane_f32              __vld1q_lane_f32
#define vld1q_lane_p16              __vld1q_lane_p16
#define vld1q_lane_p8               __vld1q_lane_p8
#define vld1q_lane_s16              __vld1q_lane_s16
#define vld1q_lane_s32              __vld1q_lane_s32
#define vld1q_lane_s8               __vld1q_lane_s8
#define vld1q_lane_u16              __vld1q_lane_u16
#define vld1q_lane_u32              __vld1q_lane_u32
#define vld1q_lane_u8               __vld1q_lane_u8
#define vld1_lane_f32_ex            __vld1_lane_f32_ex
#define vld1_lane_p16_ex            __vld1_lane_p16_ex
#define vld1_lane_s16_ex            __vld1_lane_s16_ex
#define vld1_lane_s32_ex            __vld1_lane_s32_ex
#define vld1_lane_u16_ex            __vld1_lane_u16_ex
#define vld1_lane_u32_ex            __vld1_lane_u32_ex
#define vld1q_lane_f32_ex           __vld1q_lane_f32_ex
#define vld1q_lane_p16_ex           __vld1q_lane_p16_ex
#define vld1q_lane_s16_ex           __vld1q_lane_s16_ex
#define vld1q_lane_s32_ex           __vld1q_lane_s32_ex
#define vld1q_lane_u16_ex           __vld1q_lane_u16_ex
#define vld1q_lane_u32_ex           __vld1q_lane_u32_ex
#define vld2_f32                    __vld2_f32
#define vld2_p16                    __vld2_p16
#define vld2_p8                     __vld2_p8
#define vld2_s16                    __vld2_s16
#define vld2_s32                    __vld2_s32
#define vld2_s8                     __vld2_s8
#define vld2_u16                    __vld2_u16
#define vld2_u32                    __vld2_u32
#define vld2_u8                     __vld2_u8
#define vld2_s64                    __vld2_s64
#define vld2_u64                    __vld2_u64
#define vld2_s64_ex                 __vld2_s64_ex
#define vld2_u64_ex                 __vld2_u64_ex
#define vld2_f32_ex                 __vld2_f32_ex
#define vld2_p16_ex                 __vld2_p16_ex
#define vld2_p8_ex                  __vld2_p8_ex
#define vld2_s16_ex                 __vld2_s16_ex
#define vld2_s32_ex                 __vld2_s32_ex
#define vld2_s8_ex                  __vld2_s8_ex
#define vld2_u16_ex                 __vld2_u16_ex
#define vld2_u32_ex                 __vld2_u32_ex
#define vld2_u8_ex                  __vld2_u8_ex
#define vld2q_f32                   __vld2q_f32
#define vld2q_p16                   __vld2q_p16
#define vld2q_p8                    __vld2q_p8
#define vld2q_s16                   __vld2q_s16
#define vld2q_s32                   __vld2q_s32
#define vld2q_s8                    __vld2q_s8
#define vld2q_u16                   __vld2q_u16
#define vld2q_u32                   __vld2q_u32
#define vld2q_u8                    __vld2q_u8
#define vld2q_f32_ex                __vld2q_f32_ex
#define vld2q_p16_ex                __vld2q_p16_ex
#define vld2q_p8_ex                 __vld2q_p8_ex
#define vld2q_s16_ex                __vld2q_s16_ex
#define vld2q_s32_ex                __vld2q_s32_ex
#define vld2q_s8_ex                 __vld2q_s8_ex
#define vld2q_u16_ex                __vld2q_u16_ex
#define vld2q_u32_ex                __vld2q_u32_ex
#define vld2q_u8_ex                 __vld2q_u8_ex
#define vld2_dup_f32                __vld2_dup_f32
#define vld2_dup_p16                __vld2_dup_p16
#define vld2_dup_p8                 __vld2_dup_p8
#define vld2_dup_s16                __vld2_dup_s16
#define vld2_dup_s32                __vld2_dup_s32
#define vld2_dup_s8                 __vld2_dup_s8
#define vld2_dup_u16                __vld2_dup_u16
#define vld2_dup_u32                __vld2_dup_u32
#define vld2_dup_u8                 __vld2_dup_u8
#define vld2_dup_s64                __vld2_dup_s64
#define vld2_dup_u64                __vld2_dup_u64
#define vld2_dup_s64_ex             __vld2_dup_s64_ex
#define vld2_dup_u64_ex             __vld2_dup_u64_ex
#define vld2_dup_f32_ex             __vld2_dup_f32_ex
#define vld2_dup_p16_ex             __vld2_dup_p16_ex
#define vld2_dup_p8_ex              __vld2_dup_p8_ex
#define vld2_dup_s16_ex             __vld2_dup_s16_ex
#define vld2_dup_s32_ex             __vld2_dup_s32_ex
#define vld2_dup_s8_ex              __vld2_dup_s8_ex
#define vld2_dup_u16_ex             __vld2_dup_u16_ex
#define vld2_dup_u32_ex             __vld2_dup_u32_ex
#define vld2_dup_u8_ex              __vld2_dup_u8_ex
#define vld2_lane_f32               __vld2_lane_f32
#define vld2_lane_p16               __vld2_lane_p16
#define vld2_lane_p8                __vld2_lane_p8
#define vld2_lane_s16               __vld2_lane_s16
#define vld2_lane_s32               __vld2_lane_s32
#define vld2_lane_s8                __vld2_lane_s8
#define vld2_lane_u16               __vld2_lane_u16
#define vld2_lane_u32               __vld2_lane_u32
#define vld2_lane_u8                __vld2_lane_u8
#define vld2q_lane_f32              __vld2q_lane_f32
#define vld2q_lane_p16              __vld2q_lane_p16
#define vld2q_lane_s16              __vld2q_lane_s16
#define vld2q_lane_s32              __vld2q_lane_s32
#define vld2q_lane_u16              __vld2q_lane_u16
#define vld2q_lane_u32              __vld2q_lane_u32
#define vld2_lane_f32_ex            __vld2_lane_f32_ex
#define vld2_lane_p16_ex            __vld2_lane_p16_ex
#define vld2_lane_p8_ex             __vld2_lane_p8_ex
#define vld2_lane_s16_ex            __vld2_lane_s16_ex
#define vld2_lane_s32_ex            __vld2_lane_s32_ex
#define vld2_lane_s8_ex             __vld2_lane_s8_ex
#define vld2_lane_u16_ex            __vld2_lane_u16_ex
#define vld2_lane_u32_ex            __vld2_lane_u32_ex
#define vld2_lane_u8_ex             __vld2_lane_u8_ex
#define vld2q_lane_f32_ex           __vld2q_lane_f32_ex
#define vld2q_lane_p16_ex           __vld2q_lane_p16_ex
#define vld2q_lane_s16_ex           __vld2q_lane_s16_ex
#define vld2q_lane_s32_ex           __vld2q_lane_s32_ex
#define vld2q_lane_u16_ex           __vld2q_lane_u16_ex
#define vld2q_lane_u32_ex           __vld2q_lane_u32_ex
#define vld3_f32                    __vld3_f32
#define vld3_p16                    __vld3_p16
#define vld3_p8                     __vld3_p8
#define vld3_s16                    __vld3_s16
#define vld3_s32                    __vld3_s32
#define vld3_s8                     __vld3_s8
#define vld3_u16                    __vld3_u16
#define vld3_u32                    __vld3_u32
#define vld3_u8                     __vld3_u8
#define vld3_s64                    __vld3_s64
#define vld3_u64                    __vld3_u64
#define vld3_s64_ex                 __vld3_s64_ex
#define vld3_u64_ex                 __vld3_u64_ex
#define vld3_f32_ex                 __vld3_f32_ex
#define vld3_p16_ex                 __vld3_p16_ex
#define vld3_p8_ex                  __vld3_p8_ex
#define vld3_s16_ex                 __vld3_s16_ex
#define vld3_s32_ex                 __vld3_s32_ex
#define vld3_s8_ex                  __vld3_s8_ex
#define vld3_u16_ex                 __vld3_u16_ex
#define vld3_u32_ex                 __vld3_u32_ex
#define vld3_u8_ex                  __vld3_u8_ex
#define vld3q_f32                   __vld3q_f32
#define vld3q_p16                   __vld3q_p16
#define vld3q_p8                    __vld3q_p8
#define vld3q_s16                   __vld3q_s16
#define vld3q_s32                   __vld3q_s32
#define vld3q_s8                    __vld3q_s8
#define vld3q_u16                   __vld3q_u16
#define vld3q_u32                   __vld3q_u32
#define vld3q_u8                    __vld3q_u8
#define vld3q_f32_ex                __vld3q_f32_ex
#define vld3q_p16_ex                __vld3q_p16_ex
#define vld3q_p8_ex                 __vld3q_p8_ex
#define vld3q_s16_ex                __vld3q_s16_ex
#define vld3q_s32_ex                __vld3q_s32_ex
#define vld3q_s8_ex                 __vld3q_s8_ex
#define vld3q_u16_ex                __vld3q_u16_ex
#define vld3q_u32_ex                __vld3q_u32_ex
#define vld3q_u8_ex                 __vld3q_u8_ex
#define vld3_dup_f32                __vld3_dup_f32
#define vld3_dup_p16                __vld3_dup_p16
#define vld3_dup_p8                 __vld3_dup_p8
#define vld3_dup_s16                __vld3_dup_s16
#define vld3_dup_s32                __vld3_dup_s32
#define vld3_dup_s8                 __vld3_dup_s8
#define vld3_dup_u16                __vld3_dup_u16
#define vld3_dup_u32                __vld3_dup_u32
#define vld3_dup_u8                 __vld3_dup_u8
#define vld3_dup_s64                __vld3_dup_s64
#define vld3_dup_u64                __vld3_dup_u64
#define vld3_lane_f32               __vld3_lane_f32
#define vld3_lane_p16               __vld3_lane_p16
#define vld3_lane_p8                __vld3_lane_p8
#define vld3_lane_s16               __vld3_lane_s16
#define vld3_lane_s32               __vld3_lane_s32
#define vld3_lane_s8                __vld3_lane_s8
#define vld3_lane_u16               __vld3_lane_u16
#define vld3_lane_u32               __vld3_lane_u32
#define vld3_lane_u8                __vld3_lane_u8
#define vld3q_lane_f32              __vld3q_lane_f32
#define vld3q_lane_p16              __vld3q_lane_p16
#define vld3q_lane_s16              __vld3q_lane_s16
#define vld3q_lane_s32              __vld3q_lane_s32
#define vld3q_lane_u16              __vld3q_lane_u16
#define vld3q_lane_u32              __vld3q_lane_u32
#define vld4_f32                    __vld4_f32
#define vld4_p16                    __vld4_p16
#define vld4_p8                     __vld4_p8
#define vld4_s16                    __vld4_s16
#define vld4_s32                    __vld4_s32
#define vld4_s8                     __vld4_s8
#define vld4_u16                    __vld4_u16
#define vld4_u32                    __vld4_u32
#define vld4_u8                     __vld4_u8
#define vld4_s64                    __vld4_s64
#define vld4_u64                    __vld4_u64
#define vld4_s64_ex                 __vld4_s64_ex
#define vld4_u64_ex                 __vld4_u64_ex
#define vld4_f32_ex                 __vld4_f32_ex
#define vld4_p16_ex                 __vld4_p16_ex
#define vld4_p8_ex                  __vld4_p8_ex
#define vld4_s16_ex                 __vld4_s16_ex
#define vld4_s32_ex                 __vld4_s32_ex
#define vld4_s8_ex                  __vld4_s8_ex
#define vld4_u16_ex                 __vld4_u16_ex
#define vld4_u32_ex                 __vld4_u32_ex
#define vld4_u8_ex                  __vld4_u8_ex
#define vld4q_f32                   __vld4q_f32
#define vld4q_p16                   __vld4q_p16
#define vld4q_p8                    __vld4q_p8
#define vld4q_s16                   __vld4q_s16
#define vld4q_s32                   __vld4q_s32
#define vld4q_s8                    __vld4q_s8
#define vld4q_u16                   __vld4q_u16
#define vld4q_u32                   __vld4q_u32
#define vld4q_u8                    __vld4q_u8
#define vld4q_f32_ex                __vld4q_f32_ex
#define vld4q_p16_ex                __vld4q_p16_ex
#define vld4q_p8_ex                 __vld4q_p8_ex
#define vld4q_s16_ex                __vld4q_s16_ex
#define vld4q_s32_ex                __vld4q_s32_ex
#define vld4q_s8_ex                 __vld4q_s8_ex
#define vld4q_u16_ex                __vld4q_u16_ex
#define vld4q_u32_ex                __vld4q_u32_ex
#define vld4q_u8_ex                 __vld4q_u8_ex
#define vld4_dup_f32                __vld4_dup_f32
#define vld4_dup_p16                __vld4_dup_p16
#define vld4_dup_p8                 __vld4_dup_p8
#define vld4_dup_s16                __vld4_dup_s16
#define vld4_dup_s32                __vld4_dup_s32
#define vld4_dup_s8                 __vld4_dup_s8
#define vld4_dup_u16                __vld4_dup_u16
#define vld4_dup_u32                __vld4_dup_u32
#define vld4_dup_u8                 __vld4_dup_u8
#define vld4_dup_s64                __vld4_dup_s64
#define vld4_dup_u64                __vld4_dup_u64
#define vld4_dup_f32_ex             __vld4_dup_f32_ex
#define vld4_dup_p16_ex             __vld4_dup_p16_ex
#define vld4_dup_p8_ex              __vld4_dup_p8_ex
#define vld4_dup_s16_ex             __vld4_dup_s16_ex
#define vld4_dup_s32_ex             __vld4_dup_s32_ex
#define vld4_dup_s8_ex              __vld4_dup_s8_ex
#define vld4_dup_u16_ex             __vld4_dup_u16_ex
#define vld4_dup_u32_ex             __vld4_dup_u32_ex
#define vld4_dup_u8_ex              __vld4_dup_u8_ex
#define vld4_lane_f32               __vld4_lane_f32
#define vld4_lane_p16               __vld4_lane_p16
#define vld4_lane_p8                __vld4_lane_p8
#define vld4_lane_s16               __vld4_lane_s16
#define vld4_lane_s32               __vld4_lane_s32
#define vld4_lane_s8                __vld4_lane_s8
#define vld4_lane_u16               __vld4_lane_u16
#define vld4_lane_u32               __vld4_lane_u32
#define vld4_lane_u8                __vld4_lane_u8
#define vld4q_lane_f32              __vld4q_lane_f32
#define vld4q_lane_p16              __vld4q_lane_p16
#define vld4q_lane_s16              __vld4q_lane_s16
#define vld4q_lane_s32              __vld4q_lane_s32
#define vld4q_lane_u16              __vld4q_lane_u16
#define vld4q_lane_u32              __vld4q_lane_u32
#define vld4_lane_f32_ex            __vld4_lane_f32_ex
#define vld4_lane_p16_ex            __vld4_lane_p16_ex
#define vld4_lane_p8_ex             __vld4_lane_p8_ex
#define vld4_lane_s16_ex            __vld4_lane_s16_ex
#define vld4_lane_s32_ex            __vld4_lane_s32_ex
#define vld4_lane_s8_ex             __vld4_lane_s8_ex
#define vld4_lane_u16_ex            __vld4_lane_u16_ex
#define vld4_lane_u32_ex            __vld4_lane_u32_ex
#define vld4_lane_u8_ex             __vld4_lane_u8_ex
#define vld4q_lane_f32_ex           __vld4q_lane_f32_ex
#define vld4q_lane_p16_ex           __vld4q_lane_p16_ex
#define vld4q_lane_s16_ex           __vld4q_lane_s16_ex
#define vld4q_lane_s32_ex           __vld4q_lane_s32_ex
#define vld4q_lane_u16_ex           __vld4q_lane_u16_ex
#define vld4q_lane_u32_ex           __vld4q_lane_u32_ex
#define vmax_f32                    __vmax_f32
#define vmaxnm_f32                  __vmaxnm_f32
#define vmin_f32                    __vmin_f32
#define vminnm_f32                  __vminnm_f32
#define vmaxq_f32                   __vmaxq_f32
#define vmaxnmq_f32                 __vmaxnmq_f32
#define vminq_f32                   __vminq_f32
#define vminnmq_f32                 __vminnmq_f32
#define vmax_s16                    __vmax_s16
#define vmax_s32                    __vmax_s32
#define vmax_s8                     __vmax_s8
#define vmax_u16                    __vmax_u16
#define vmax_u32                    __vmax_u32
#define vmax_u8                     __vmax_u8
#define vmin_s16                    __vmin_s16
#define vmin_s32                    __vmin_s32
#define vmin_s8                     __vmin_s8
#define vmin_u16                    __vmin_u16
#define vmin_u32                    __vmin_u32
#define vmin_u8                     __vmin_u8
#define vmaxq_s16                   __vmaxq_s16
#define vmaxq_s32                   __vmaxq_s32
#define vmaxq_s8                    __vmaxq_s8
#define vmaxq_u16                   __vmaxq_u16
#define vmaxq_u32                   __vmaxq_u32
#define vmaxq_u8                    __vmaxq_u8
#define vminq_s16                   __vminq_s16
#define vminq_s32                   __vminq_s32
#define vminq_s8                    __vminq_s8
#define vminq_u16                   __vminq_u16
#define vminq_u32                   __vminq_u32
#define vminq_u8                    __vminq_u8
#define vmla_lane_f32               __vmla_lane_f32
#define vmla_lane_s16               __vmla_lane_s16
#define vmla_lane_s32               __vmla_lane_s32
#define vmla_lane_u16               __vmla_lane_u16
#define vmla_lane_u32               __vmla_lane_u32
#define vmls_lane_f32               __vmls_lane_f32
#define vmls_lane_s16               __vmls_lane_s16
#define vmls_lane_s32               __vmls_lane_s32
#define vmls_lane_u16               __vmls_lane_u16
#define vmls_lane_u32               __vmls_lane_u32
#define vmlaq_lane_f32              __vmlaq_lane_f32
#define vmlaq_lane_s16              __vmlaq_lane_s16
#define vmlaq_lane_s32              __vmlaq_lane_s32
#define vmlaq_lane_u16              __vmlaq_lane_u16
#define vmlaq_lane_u32              __vmlaq_lane_u32
#define vmlsq_lane_f32              __vmlsq_lane_f32
#define vmlsq_lane_s16              __vmlsq_lane_s16
#define vmlsq_lane_s32              __vmlsq_lane_s32
#define vmlsq_lane_u16              __vmlsq_lane_u16
#define vmlsq_lane_u32              __vmlsq_lane_u32
#define vmla_n_f32                  __vmla_n_f32
#define vmls_n_f32                  __vmls_n_f32
#define vmlaq_n_f32                 __vmlaq_n_f32
#define vmlsq_n_f32                 __vmlsq_n_f32
#define vmla_f32                    __vmla_f32
#define vfma_f32                    __vmla_f32
#define vfmaq_f32                   __vmlaq_f32
#define vmls_f32                    __vmls_f32
#define vfms_f32                    __vmls_f32
#define vfmsq_f32                   __vmlsq_f32
#define vmlaq_f32                   __vmlaq_f32
#define vmlsq_f32                   __vmlsq_f32
#define vmla_s16                    __vmla_s16
#define vmla_s32                    __vmla_s32
#define vmla_s8                     __vmla_s8
#define vmla_u16                    __vmla_u16
#define vmla_u32                    __vmla_u32
#define vmla_u8                     __vmla_u8
#define vmls_s16                    __vmls_s16
#define vmls_s32                    __vmls_s32
#define vmls_s8                     __vmls_s8
#define vmls_u16                    __vmls_u16
#define vmls_u32                    __vmls_u32
#define vmls_u8                     __vmls_u8
#define vmlaq_s16                   __vmlaq_s16
#define vmlaq_s32                   __vmlaq_s32
#define vmlaq_s8                    __vmlaq_s8
#define vmlaq_u16                   __vmlaq_u16
#define vmlaq_u32                   __vmlaq_u32
#define vmlaq_u8                    __vmlaq_u8
#define vmlsq_s16                   __vmlsq_s16
#define vmlsq_s32                   __vmlsq_s32
#define vmlsq_s8                    __vmlsq_s8
#define vmlsq_u16                   __vmlsq_u16
#define vmlsq_u32                   __vmlsq_u32
#define vmlsq_u8                    __vmlsq_u8
#define vmlal_s16                   __vmlal_s16
#define vmlal_s32                   __vmlal_s32
#define vmlal_s8                    __vmlal_s8
#define vmlal_u16                   __vmlal_u16
#define vmlal_u32                   __vmlal_u32
#define vmlal_u8                    __vmlal_u8
#define vmlsl_s16                   __vmlsl_s16
#define vmlsl_s32                   __vmlsl_s32
#define vmlsl_s8                    __vmlsl_s8
#define vmlsl_u16                   __vmlsl_u16
#define vmlsl_u32                   __vmlsl_u32
#define vmlsl_u8                    __vmlsl_u8
#define vmlal_lane_s16              __vmlal_lane_s16
#define vmlal_lane_s32              __vmlal_lane_s32
#define vmlal_lane_u16              __vmlal_lane_u16
#define vmlal_lane_u32              __vmlal_lane_u32
#define vmlsl_lane_s16              __vmlsl_lane_s16
#define vmlsl_lane_s32              __vmlsl_lane_s32
#define vmlsl_lane_u16              __vmlsl_lane_u16
#define vmlsl_lane_u32              __vmlsl_lane_u32
#define vset_lane_f32               __vset_lane_f32
#define vset_lane_p16               __vset_lane_p16
#define vset_lane_p8                __vset_lane_p8
#define vset_lane_s16               __vset_lane_s16
#define vset_lane_s32               __vset_lane_s32
#define vset_lane_s8                __vset_lane_s8
#define vset_lane_u16               __vset_lane_u16
#define vset_lane_u32               __vset_lane_u32
#define vset_lane_u8                __vset_lane_u8
#define vget_lane_f32               __vget_lane_f32
#define vget_lane_p16               __vget_lane_p16
#define vget_lane_p8                __vget_lane_p8
#define vget_lane_s16               __vget_lane_s16
#define vget_lane_s8                __vget_lane_s8
#define vget_lane_s32               __vget_lane_s32
#define vget_lane_u16               __vget_lane_u16
#define vget_lane_u8                __vget_lane_u8
#define vget_lane_u32               __vget_lane_u32
#define vset_lane_s64               __vset_lane_s64
#define vset_lane_u64               __vset_lane_u64
#define vsetq_lane_s64              __vsetq_lane_s64
#define vsetq_lane_u64              __vsetq_lane_u64
#define vget_lane_s64               __vget_lane_s64
#define vget_lane_u64               __vget_lane_u64
#define vgetq_lane_s64              __vgetq_lane_s64
#define vgetq_lane_u64              __vgetq_lane_u64
#define vsetq_lane_f32              __vsetq_lane_f32
#define vsetq_lane_p16              __vsetq_lane_p16
#define vsetq_lane_p8               __vsetq_lane_p8
#define vsetq_lane_s16              __vsetq_lane_s16
#define vsetq_lane_s32              __vsetq_lane_s32
#define vsetq_lane_s8               __vsetq_lane_s8
#define vsetq_lane_u16              __vsetq_lane_u16
#define vsetq_lane_u32              __vsetq_lane_u32
#define vsetq_lane_u8               __vsetq_lane_u8
#define vgetq_lane_f32              __vgetq_lane_f32
#define vgetq_lane_p16              __vgetq_lane_p16
#define vgetq_lane_p8               __vgetq_lane_p8
#define vgetq_lane_s16              __vgetq_lane_s16
#define vgetq_lane_s8               __vgetq_lane_s8
#define vgetq_lane_s32              __vgetq_lane_s32
#define vgetq_lane_u16              __vgetq_lane_u16
#define vgetq_lane_u8               __vgetq_lane_u8
#define vgetq_lane_u32              __vgetq_lane_u32
#define vmovl_s16                   __vmovl_s16
#define vmovl_s32                   __vmovl_s32
#define vmovl_s8                    __vmovl_s8
#define vmovl_u16                   __vmovl_u16
#define vmovl_u32                   __vmovl_u32
#define vmovl_u8                    __vmovl_u8
#define vmovn_s16                   __vmovn_s16
#define vmovn_s32                   __vmovn_s32
#define vmovn_s64                   __vmovn_s64
#define vmovn_u16                   __vmovn_u16
#define vmovn_u32                   __vmovn_u32
#define vmovn_u64                   __vmovn_u64
#define vmul_f32                    __vmul_f32
#define vmul_p8                     __vmul_p8
#define vmul_s16                    __vmul_s16
#define vmul_s32                    __vmul_s32
#define vmul_s8                     __vmul_s8
#define vmul_u16                    __vmul_u16
#define vmul_u32                    __vmul_u32
#define vmul_u8                     __vmul_u8
#define vmulq_f32                   __vmulq_f32
#define vmulq_p8                    __vmulq_p8
#define vmulq_s16                   __vmulq_s16
#define vmulq_s32                   __vmulq_s32
#define vmulq_s8                    __vmulq_s8
#define vmulq_u16                   __vmulq_u16
#define vmulq_u32                   __vmulq_u32
#define vmulq_u8                    __vmulq_u8
#define vmul_n_f32                  __vmul_n_f32
#define vmulq_n_f32                 __vmulq_n_f32
#define vmul_lane_f32               __vmul_lane_f32
#define vmul_lane_s16               __vmul_lane_s16
#define vmul_lane_s32               __vmul_lane_s32
#define vmul_lane_u16               __vmul_lane_u16
#define vmul_lane_u32               __vmul_lane_u32
#define vmulq_lane_f32              __vmulq_lane_f32
#define vmulq_lane_s16              __vmulq_lane_s16
#define vmulq_lane_s32              __vmulq_lane_s32
#define vmulq_lane_u16              __vmulq_lane_u16
#define vmulq_lane_u32              __vmulq_lane_u32
#define vmull_p64                   __vmull_p64
#define vmull_p8                    __vmull_p8
#define vmull_s16                   __vmull_s16
#define vmull_s32                   __vmull_s32
#define vmull_s8                    __vmull_s8
#define vmull_u16                   __vmull_u16
#define vmull_u32                   __vmull_u32
#define vmull_u8                    __vmull_u8
#define vmull_lane_s16              __vmull_lane_s16
#define vmull_lane_s32              __vmull_lane_s32
#define vmull_lane_u16              __vmull_lane_u16
#define vmull_lane_u32              __vmull_lane_u32
#define vmvn_p16                    __vmvn_p16
#define vmvn_p8                     __vmvn_p8
#define vmvn_s16                    __vmvn_s16
#define vmvn_s32                    __vmvn_s32
#define vmvn_s8                     __vmvn_s8
#define vmvn_u16                    __vmvn_u16
#define vmvn_u32                    __vmvn_u32
#define vmvn_u8                     __vmvn_u8
#define vmvnq_p16                   __vmvnq_p16
#define vmvnq_p8                    __vmvnq_p8
#define vmvnq_s16                   __vmvnq_s16
#define vmvnq_s32                   __vmvnq_s32
#define vmvnq_s8                    __vmvnq_s8
#define vmvnq_u16                   __vmvnq_u16
#define vmvnq_u32                   __vmvnq_u32
#define vmvnq_u8                    __vmvnq_u8
#define vpadal_s16                  __vpadal_s16
#define vpadal_s32                  __vpadal_s32
#define vpadal_s8                   __vpadal_s8
#define vpadal_u16                  __vpadal_u16
#define vpadal_u32                  __vpadal_u32
#define vpadal_u8                   __vpadal_u8
#define vpadalq_s16                 __vpadalq_s16
#define vpadalq_s32                 __vpadalq_s32
#define vpadalq_s8                  __vpadalq_s8
#define vpadalq_u16                 __vpadalq_u16
#define vpadalq_u32                 __vpadalq_u32
#define vpadalq_u8                  __vpadalq_u8
#define vpadd_f32                   __vpadd_f32
#define vpadd_s16                   __vpadd_s16
#define vpadd_s32                   __vpadd_s32
#define vpadd_s8                    __vpadd_s8
#define vpadd_u16                   __vpadd_u16
#define vpadd_u32                   __vpadd_u32
#define vpadd_u8                    __vpadd_u8
#define vpaddl_s16                  __vpaddl_s16
#define vpaddl_s32                  __vpaddl_s32
#define vpaddl_s8                   __vpaddl_s8
#define vpaddl_u16                  __vpaddl_u16
#define vpaddl_u32                  __vpaddl_u32
#define vpaddl_u8                   __vpaddl_u8
#define vpaddlq_s16                 __vpaddlq_s16
#define vpaddlq_s32                 __vpaddlq_s32
#define vpaddlq_s8                  __vpaddlq_s8
#define vpaddlq_u16                 __vpaddlq_u16
#define vpaddlq_u32                 __vpaddlq_u32
#define vpaddlq_u8                  __vpaddlq_u8
#define vpmax_f32                   __vpmax_f32
#define vpmin_f32                   __vpmin_f32
#define vpmax_s16                   __vpmax_s16
#define vpmax_s32                   __vpmax_s32
#define vpmax_s8                    __vpmax_s8
#define vpmax_u16                   __vpmax_u16
#define vpmax_u32                   __vpmax_u32
#define vpmax_u8                    __vpmax_u8
#define vpmin_s16                   __vpmin_s16
#define vpmin_s32                   __vpmin_s32
#define vpmin_s8                    __vpmin_s8
#define vpmin_u16                   __vpmin_u16
#define vpmin_u32                   __vpmin_u32
#define vpmin_u8                    __vpmin_u8
#define vqabs_s16                   __vqabs_s16
#define vqabs_s32                   __vqabs_s32
#define vqabs_s8                    __vqabs_s8
#define vqneg_s16                   __vqneg_s16
#define vqneg_s32                   __vqneg_s32
#define vqneg_s8                    __vqneg_s8
#define vqabsq_s16                  __vqabsq_s16
#define vqabsq_s32                  __vqabsq_s32
#define vqabsq_s8                   __vqabsq_s8
#define vqnegq_s16                  __vqnegq_s16
#define vqnegq_s32                  __vqnegq_s32
#define vqnegq_s8                   __vqnegq_s8
#define vqadd_s16                   __vqadd_s16
#define vqadd_s32                   __vqadd_s32
#define vqadd_s64                   __vqadd_s64
#define vqadd_s8                    __vqadd_s8
#define vqadd_u16                   __vqadd_u16
#define vqadd_u32                   __vqadd_u32
#define vqadd_u64                   __vqadd_u64
#define vqadd_u8                    __vqadd_u8
#define vqaddq_s16                  __vqaddq_s16
#define vqaddq_s32                  __vqaddq_s32
#define vqaddq_s64                  __vqaddq_s64
#define vqaddq_s8                   __vqaddq_s8
#define vqaddq_u16                  __vqaddq_u16
#define vqaddq_u32                  __vqaddq_u32
#define vqaddq_u64                  __vqaddq_u64
#define vqaddq_u8                   __vqaddq_u8
#define vqdmlal_s16                 __vqdmlal_s16
#define vqdmlal_s32                 __vqdmlal_s32
#define vqdmlsl_s16                 __vqdmlsl_s16
#define vqdmlsl_s32                 __vqdmlsl_s32
#define vqdmlal_lane_s16            __vqdmlal_lane_s16
#define vqdmlal_lane_s32            __vqdmlal_lane_s32
#define vqdmlsl_lane_s16            __vqdmlsl_lane_s16
#define vqdmlsl_lane_s32            __vqdmlsl_lane_s32
#define vqdmulh_lane_s16            __vqdmulh_lane_s16
#define vqdmulh_lane_s32            __vqdmulh_lane_s32
#define vqrdmulh_lane_s16           __vqrdmulh_lane_s16
#define vqrdmulh_lane_s32           __vqrdmulh_lane_s32
#define vqdmulhq_lane_s16           __vqdmulhq_lane_s16
#define vqdmulhq_lane_s32           __vqdmulhq_lane_s32
#define vqrdmulhq_lane_s16          __vqrdmulhq_lane_s16
#define vqrdmulhq_lane_s32          __vqrdmulhq_lane_s32
#define vqdmulh_s16                 __vqdmulh_s16
#define vqdmulh_s32                 __vqdmulh_s32
#define vqrdmulh_s16                __vqrdmulh_s16
#define vqrdmulh_s32                __vqrdmulh_s32
#define vqdmulhq_s16                __vqdmulhq_s16
#define vqdmulhq_s32                __vqdmulhq_s32
#define vqrdmulhq_s16               __vqrdmulhq_s16
#define vqrdmulhq_s32               __vqrdmulhq_s32
#define vqdmull_s16                 __vqdmull_s16
#define vqdmull_s32                 __vqdmull_s32
#define vqdmull_lane_s16            __vqdmull_lane_s16
#define vqdmull_lane_s32            __vqdmull_lane_s32
#define vqmovn_s16                  __vqmovn_s16
#define vqmovn_s32                  __vqmovn_s32
#define vqmovn_s64                  __vqmovn_s64
#define vqmovn_u16                  __vqmovn_u16
#define vqmovn_u32                  __vqmovn_u32
#define vqmovn_u64                  __vqmovn_u64
#define vqmovun_s16                 __vqmovun_s16
#define vqmovun_s32                 __vqmovun_s32
#define vqmovun_s64                 __vqmovun_s64
#define vqshl_n_s16                 __vqshl_n_s16
#define vqshl_n_s32                 __vqshl_n_s32
#define vqshl_n_s64                 __vqshl_n_s64
#define vqshl_n_s8                  __vqshl_n_s8
#define vqshl_n_u16                 __vqshl_n_u16
#define vqshl_n_u32                 __vqshl_n_u32
#define vqshl_n_u64                 __vqshl_n_u64
#define vqshl_n_u8                  __vqshl_n_u8
#define vqshlu_n_s16                __vqshlu_n_s16
#define vqshlu_n_s32                __vqshlu_n_s32
#define vqshlu_n_s64                __vqshlu_n_s64
#define vqshlu_n_s8                 __vqshlu_n_s8
#define vqshlq_n_s16                __vqshlq_n_s16
#define vqshlq_n_s32                __vqshlq_n_s32
#define vqshlq_n_s64                __vqshlq_n_s64
#define vqshlq_n_s8                 __vqshlq_n_s8
#define vqshlq_n_u16                __vqshlq_n_u16
#define vqshlq_n_u32                __vqshlq_n_u32
#define vqshlq_n_u64                __vqshlq_n_u64
#define vqshlq_n_u8                 __vqshlq_n_u8
#define vqshluq_n_s16               __vqshluq_n_s16
#define vqshluq_n_s32               __vqshluq_n_s32
#define vqshluq_n_s64               __vqshluq_n_s64
#define vqshluq_n_s8                __vqshluq_n_s8
#define vqrshrn_n_s16               __vqrshrn_n_s16
#define vqrshrn_n_s32               __vqrshrn_n_s32
#define vqrshrn_n_s64               __vqrshrn_n_s64
#define vqrshrn_n_u16               __vqrshrn_n_u16
#define vqrshrn_n_u32               __vqrshrn_n_u32
#define vqrshrn_n_u64               __vqrshrn_n_u64
#define vqrshrun_n_s16              __vqrshrun_n_s16
#define vqrshrun_n_s32              __vqrshrun_n_s32
#define vqrshrun_n_s64              __vqrshrun_n_s64
#define vqshrn_n_s16                __vqshrn_n_s16
#define vqshrn_n_s32                __vqshrn_n_s32
#define vqshrn_n_s64                __vqshrn_n_s64
#define vqshrn_n_u16                __vqshrn_n_u16
#define vqshrn_n_u32                __vqshrn_n_u32
#define vqshrn_n_u64                __vqshrn_n_u64
#define vqshrun_n_s16               __vqshrun_n_s16
#define vqshrun_n_s32               __vqshrun_n_s32
#define vqshrun_n_s64               __vqshrun_n_s64
#define vqsub_s16                   __vqsub_s16
#define vqsub_s32                   __vqsub_s32
#define vqsub_s64                   __vqsub_s64
#define vqsub_s8                    __vqsub_s8
#define vqsub_u16                   __vqsub_u16
#define vqsub_u32                   __vqsub_u32
#define vqsub_u64                   __vqsub_u64
#define vqsub_u8                    __vqsub_u8
#define vqsubq_s16                  __vqsubq_s16
#define vqsubq_s32                  __vqsubq_s32
#define vqsubq_s64                  __vqsubq_s64
#define vqsubq_s8                   __vqsubq_s8
#define vqsubq_u16                  __vqsubq_u16
#define vqsubq_u32                  __vqsubq_u32
#define vqsubq_u64                  __vqsubq_u64
#define vqsubq_u8                   __vqsubq_u8
#define vrecpe_f32                  __vrecpe_f32
#define vrecpe_u32                  __vrecpe_u32
#define vrsqrte_f32                 __vrsqrte_f32
#define vrsqrte_u32                 __vrsqrte_u32
#define vrecpeq_f32                 __vrecpeq_f32
#define vrecpeq_u32                 __vrecpeq_u32
#define vrsqrteq_f32                __vrsqrteq_f32
#define vrsqrteq_u32                __vrsqrteq_u32
#define vrecps_f32                  __vrecps_f32
#define vrecpsq_f32                 __vrecpsq_f32
#define vrev16_p8                   __vrev16_p8
#define vrev16_s8                   __vrev16_s8
#define vrev16_u8                   __vrev16_u8
#define vrev32_p16                  __vrev32_p16
#define vrev32_p8                   __vrev32_p8
#define vrev32_s16                  __vrev32_s16
#define vrev32_s8                   __vrev32_s8
#define vrev32_u16                  __vrev32_u16
#define vrev32_u8                   __vrev32_u8
#define vrev64_f32                  __vrev64_f32
#define vrev64_p16                  __vrev64_p16
#define vrev64_p8                   __vrev64_p8
#define vrev64_s16                  __vrev64_s16
#define vrev64_s32                  __vrev64_s32
#define vrev64_s8                   __vrev64_s8
#define vrev64_u16                  __vrev64_u16
#define vrev64_u32                  __vrev64_u32
#define vrev64_u8                   __vrev64_u8
#define vrev16q_p8                  __vrev16q_p8
#define vrev16q_s8                  __vrev16q_s8
#define vrev16q_u8                  __vrev16q_u8
#define vrev32q_p16                 __vrev32q_p16
#define vrev32q_p8                  __vrev32q_p8
#define vrev32q_s16                 __vrev32q_s16
#define vrev32q_s8                  __vrev32q_s8
#define vrev32q_u16                 __vrev32q_u16
#define vrev32q_u8                  __vrev32q_u8
#define vrev64q_f32                 __vrev64q_f32
#define vrev64q_p16                 __vrev64q_p16
#define vrev64q_p8                  __vrev64q_p8
#define vrev64q_s16                 __vrev64q_s16
#define vrev64q_s32                 __vrev64q_s32
#define vrev64q_s8                  __vrev64q_s8
#define vrev64q_u16                 __vrev64q_u16
#define vrev64q_u32                 __vrev64q_u32
#define vrev64q_u8                  __vrev64q_u8
#define vrnd_f32                    __vrnd_f32
#define vrnda_f32                   __vrnda_f32
#define vrndm_f32                   __vrndm_f32
#define vrndn_f32                   __vrndn_f32
#define vrndp_f32                   __vrndp_f32
#define vrndx_f32                   __vrndx_f32
#define vrndq_f32                   __vrndq_f32
#define vrndaq_f32                  __vrndaq_f32
#define vrndmq_f32                  __vrndmq_f32
#define vrndnq_f32                  __vrndnq_f32
#define vrndpq_f32                  __vrndpq_f32
#define vrndxq_f32                  __vrndxq_f32
#define vrsqrts_f32                 __vrsqrts_f32
#define vrsqrtsq_f32                __vrsqrtsq_f32
#define vshl_n_s16                  __vshl_n_s16
#define vshl_n_s32                  __vshl_n_s32
#define vshl_n_s64                  __vshl_n_s64
#define vshl_n_s8                   __vshl_n_s8
#define vshl_n_u16                  __vshl_n_u16
#define vshl_n_u32                  __vshl_n_u32
#define vshl_n_u64                  __vshl_n_u64
#define vshl_n_u8                   __vshl_n_u8
#define vshlq_n_s16                 __vshlq_n_s16
#define vshlq_n_s32                 __vshlq_n_s32
#define vshlq_n_s64                 __vshlq_n_s64
#define vshlq_n_s8                  __vshlq_n_s8
#define vshlq_n_u16                 __vshlq_n_u16
#define vshlq_n_u32                 __vshlq_n_u32
#define vshlq_n_u64                 __vshlq_n_u64
#define vshlq_n_u8                  __vshlq_n_u8
#define vqrshl_s16                  __vqrshl_s16
#define vqrshl_s32                  __vqrshl_s32
#define vqrshl_s64                  __vqrshl_s64
#define vqrshl_s8                   __vqrshl_s8
#define vqrshl_u16                  __vqrshl_u16
#define vqrshl_u32                  __vqrshl_u32
#define vqrshl_u64                  __vqrshl_u64
#define vqrshl_u8                   __vqrshl_u8
#define vqshl_s16                   __vqshl_s16
#define vqshl_s32                   __vqshl_s32
#define vqshl_s64                   __vqshl_s64
#define vqshl_s8                    __vqshl_s8
#define vqshl_u16                   __vqshl_u16
#define vqshl_u32                   __vqshl_u32
#define vqshl_u64                   __vqshl_u64
#define vqshl_u8                    __vqshl_u8
#define vrshl_s16                   __vrshl_s16
#define vrshl_s32                   __vrshl_s32
#define vrshl_s64                   __vrshl_s64
#define vrshl_s8                    __vrshl_s8
#define vrshl_u16                   __vrshl_u16
#define vrshl_u32                   __vrshl_u32
#define vrshl_u64                   __vrshl_u64
#define vrshl_u8                    __vrshl_u8
#define vshl_s16                    __vshl_s16
#define vshl_s32                    __vshl_s32
#define vshl_s64                    __vshl_s64
#define vshl_s8                     __vshl_s8
#define vshl_u16                    __vshl_u16
#define vshl_u32                    __vshl_u32
#define vshl_u64                    __vshl_u64
#define vshl_u8                     __vshl_u8
#define vqrshlq_s16                 __vqrshlq_s16
#define vqrshlq_s32                 __vqrshlq_s32
#define vqrshlq_s64                 __vqrshlq_s64
#define vqrshlq_s8                  __vqrshlq_s8
#define vqrshlq_u16                 __vqrshlq_u16
#define vqrshlq_u32                 __vqrshlq_u32
#define vqrshlq_u64                 __vqrshlq_u64
#define vqrshlq_u8                  __vqrshlq_u8
#define vqshlq_s16                  __vqshlq_s16
#define vqshlq_s32                  __vqshlq_s32
#define vqshlq_s64                  __vqshlq_s64
#define vqshlq_s8                   __vqshlq_s8
#define vqshlq_u16                  __vqshlq_u16
#define vqshlq_u32                  __vqshlq_u32
#define vqshlq_u64                  __vqshlq_u64
#define vqshlq_u8                   __vqshlq_u8
#define vrshlq_s16                  __vrshlq_s16
#define vrshlq_s32                  __vrshlq_s32
#define vrshlq_s64                  __vrshlq_s64
#define vrshlq_s8                   __vrshlq_s8
#define vrshlq_u16                  __vrshlq_u16
#define vrshlq_u32                  __vrshlq_u32
#define vrshlq_u64                  __vrshlq_u64
#define vrshlq_u8                   __vrshlq_u8
#define vshlq_s16                   __vshlq_s16
#define vshlq_s32                   __vshlq_s32
#define vshlq_s64                   __vshlq_s64
#define vshlq_s8                    __vshlq_s8
#define vshlq_u16                   __vshlq_u16
#define vshlq_u32                   __vshlq_u32
#define vshlq_u64                   __vshlq_u64
#define vshlq_u8                    __vshlq_u8
#define vshll_n_s16                 __vshll_n_s16
#define vshll_n_s32                 __vshll_n_s32
#define vshll_n_s8                  __vshll_n_s8
#define vshll_n_u16                 __vshll_n_u16
#define vshll_n_u32                 __vshll_n_u32
#define vshll_n_u8                  __vshll_n_u8
#define vrshr_n_s16                 __vrshr_n_s16
#define vrshr_n_s32                 __vrshr_n_s32
#define vrshr_n_s64                 __vrshr_n_s64
#define vrshr_n_s8                  __vrshr_n_s8
#define vrshr_n_u16                 __vrshr_n_u16
#define vrshr_n_u32                 __vrshr_n_u32
#define vrshr_n_u64                 __vrshr_n_u64
#define vrshr_n_u8                  __vrshr_n_u8
#define vshr_n_s16                  __vshr_n_s16
#define vshr_n_s32                  __vshr_n_s32
#define vshr_n_s64                  __vshr_n_s64
#define vshr_n_s8                   __vshr_n_s8
#define vshr_n_u16                  __vshr_n_u16
#define vshr_n_u32                  __vshr_n_u32
#define vshr_n_u64                  __vshr_n_u64
#define vshr_n_u8                   __vshr_n_u8
#define vrshrq_n_s16                __vrshrq_n_s16
#define vrshrq_n_s32                __vrshrq_n_s32
#define vrshrq_n_s64                __vrshrq_n_s64
#define vrshrq_n_s8                 __vrshrq_n_s8
#define vrshrq_n_u16                __vrshrq_n_u16
#define vrshrq_n_u32                __vrshrq_n_u32
#define vrshrq_n_u64                __vrshrq_n_u64
#define vrshrq_n_u8                 __vrshrq_n_u8
#define vshrq_n_s16                 __vshrq_n_s16
#define vshrq_n_s32                 __vshrq_n_s32
#define vshrq_n_s64                 __vshrq_n_s64
#define vshrq_n_s8                  __vshrq_n_s8
#define vshrq_n_u16                 __vshrq_n_u16
#define vshrq_n_u32                 __vshrq_n_u32
#define vshrq_n_u64                 __vshrq_n_u64
#define vshrq_n_u8                  __vshrq_n_u8
#define vrshrn_n_s16                __vrshrn_n_s16
#define vrshrn_n_s32                __vrshrn_n_s32
#define vrshrn_n_s64                __vrshrn_n_s64
#define vrshrn_n_u16                __vrshrn_n_u16
#define vrshrn_n_u32                __vrshrn_n_u32
#define vrshrn_n_u64                __vrshrn_n_u64
#define vshrn_n_s16                 __vshrn_n_s16
#define vshrn_n_s32                 __vshrn_n_s32
#define vshrn_n_s64                 __vshrn_n_s64
#define vshrn_n_u16                 __vshrn_n_u16
#define vshrn_n_u32                 __vshrn_n_u32
#define vshrn_n_u64                 __vshrn_n_u64
#define vsli_n_p16                  __vsli_n_p16
#define vsli_n_p8                   __vsli_n_p8
#define vsli_n_s16                  __vsli_n_s16
#define vsli_n_s32                  __vsli_n_s32
#define vsli_n_s64                  __vsli_n_s64
#define vsli_n_s8                   __vsli_n_s8
#define vsli_n_u16                  __vsli_n_u16
#define vsli_n_u32                  __vsli_n_u32
#define vsli_n_u64                  __vsli_n_u64
#define vsli_n_u8                   __vsli_n_u8
#define vsliq_n_p16                 __vsliq_n_p16
#define vsliq_n_p8                  __vsliq_n_p8
#define vsliq_n_s16                 __vsliq_n_s16
#define vsliq_n_s32                 __vsliq_n_s32
#define vsliq_n_s64                 __vsliq_n_s64
#define vsliq_n_s8                  __vsliq_n_s8
#define vsliq_n_u16                 __vsliq_n_u16
#define vsliq_n_u32                 __vsliq_n_u32
#define vsliq_n_u64                 __vsliq_n_u64
#define vsliq_n_u8                  __vsliq_n_u8
#define vrsra_n_s16                 __vrsra_n_s16
#define vrsra_n_s32                 __vrsra_n_s32
#define vrsra_n_s64                 __vrsra_n_s64
#define vrsra_n_s8                  __vrsra_n_s8
#define vrsra_n_u16                 __vrsra_n_u16
#define vrsra_n_u32                 __vrsra_n_u32
#define vrsra_n_u64                 __vrsra_n_u64
#define vrsra_n_u8                  __vrsra_n_u8
#define vsra_n_s16                  __vsra_n_s16
#define vsra_n_s32                  __vsra_n_s32
#define vsra_n_s64                  __vsra_n_s64
#define vsra_n_s8                   __vsra_n_s8
#define vsra_n_u16                  __vsra_n_u16
#define vsra_n_u32                  __vsra_n_u32
#define vsra_n_u64                  __vsra_n_u64
#define vsra_n_u8                   __vsra_n_u8
#define vrsraq_n_s16                __vrsraq_n_s16
#define vrsraq_n_s32                __vrsraq_n_s32
#define vrsraq_n_s64                __vrsraq_n_s64
#define vrsraq_n_s8                 __vrsraq_n_s8
#define vrsraq_n_u16                __vrsraq_n_u16
#define vrsraq_n_u32                __vrsraq_n_u32
#define vrsraq_n_u64                __vrsraq_n_u64
#define vrsraq_n_u8                 __vrsraq_n_u8
#define vsraq_n_s16                 __vsraq_n_s16
#define vsraq_n_s32                 __vsraq_n_s32
#define vsraq_n_s64                 __vsraq_n_s64
#define vsraq_n_s8                  __vsraq_n_s8
#define vsraq_n_u16                 __vsraq_n_u16
#define vsraq_n_u32                 __vsraq_n_u32
#define vsraq_n_u64                 __vsraq_n_u64
#define vsraq_n_u8                  __vsraq_n_u8
#define vsri_n_p16                  __vsri_n_p16
#define vsri_n_p8                   __vsri_n_p8
#define vsri_n_s16                  __vsri_n_s16
#define vsri_n_s32                  __vsri_n_s32
#define vsri_n_s64                  __vsri_n_s64
#define vsri_n_s8                   __vsri_n_s8
#define vsri_n_u16                  __vsri_n_u16
#define vsri_n_u32                  __vsri_n_u32
#define vsri_n_u64                  __vsri_n_u64
#define vsri_n_u8                   __vsri_n_u8
#define vsriq_n_p16                 __vsriq_n_p16
#define vsriq_n_p8                  __vsriq_n_p8
#define vsriq_n_s16                 __vsriq_n_s16
#define vsriq_n_s32                 __vsriq_n_s32
#define vsriq_n_s64                 __vsriq_n_s64
#define vsriq_n_s8                  __vsriq_n_s8
#define vsriq_n_u16                 __vsriq_n_u16
#define vsriq_n_u32                 __vsriq_n_u32
#define vsriq_n_u64                 __vsriq_n_u64
#define vsriq_n_u8                  __vsriq_n_u8
#define vst1_f32                    __vst1_f32
#define vst1_p16                    __vst1_p16
#define vst1_p8                     __vst1_p8
#define vst1_s16                    __vst1_s16
#define vst1_s32                    __vst1_s32
#define vst1_s64                    __vst1_s64
#define vst1_s8                     __vst1_s8
#define vst1_u16                    __vst1_u16
#define vst1_u32                    __vst1_u32
#define vst1_u64                    __vst1_u64
#define vst1_u8                     __vst1_u8
#define vst1_f32_ex                 __vst1_f32_ex
#define vst1_p16_ex                 __vst1_p16_ex
#define vst1_p8_ex                  __vst1_p8_ex
#define vst1_s16_ex                 __vst1_s16_ex
#define vst1_s32_ex                 __vst1_s32_ex
#define vst1_s64_ex                 __vst1_s64_ex
#define vst1_s8_ex                  __vst1_s8_ex
#define vst1_u16_ex                 __vst1_u16_ex
#define vst1_u32_ex                 __vst1_u32_ex
#define vst1_u64_ex                 __vst1_u64_ex
#define vst1_u8_ex                  __vst1_u8_ex
#define vst1q_f32                   __vst1q_f32
#define vst1q_p16                   __vst1q_p16
#define vst1q_p8                    __vst1q_p8
#define vst1q_s16                   __vst1q_s16
#define vst1q_s32                   __vst1q_s32
#define vst1q_s64                   __vst1q_s64
#define vst1q_s8                    __vst1q_s8
#define vst1q_u16                   __vst1q_u16
#define vst1q_u32                   __vst1q_u32
#define vst1q_u64                   __vst1q_u64
#define vst1q_u8                    __vst1q_u8
#define vst1q_f32_ex                __vst1q_f32_ex
#define vst1q_p16_ex                __vst1q_p16_ex
#define vst1q_p8_ex                 __vst1q_p8_ex
#define vst1q_s16_ex                __vst1q_s16_ex
#define vst1q_s32_ex                __vst1q_s32_ex
#define vst1q_s64_ex                __vst1q_s64_ex
#define vst1q_s8_ex                 __vst1q_s8_ex
#define vst1q_u16_ex                __vst1q_u16_ex
#define vst1q_u32_ex                __vst1q_u32_ex
#define vst1q_u64_ex                __vst1q_u64_ex
#define vst1q_u8_ex                 __vst1q_u8_ex
#define vst1_lane_f32               __vst1_lane_f32
#define vst1_lane_p16               __vst1_lane_p16
#define vst1_lane_p8                __vst1_lane_p8
#define vst1_lane_s16               __vst1_lane_s16
#define vst1_lane_s32               __vst1_lane_s32
#define vst1_lane_s8                __vst1_lane_s8
#define vst1_lane_u16               __vst1_lane_u16
#define vst1_lane_u32               __vst1_lane_u32
#define vst1_lane_u8                __vst1_lane_u8
#define vst1q_lane_f32              __vst1q_lane_f32
#define vst1q_lane_p16              __vst1q_lane_p16
#define vst1q_lane_p8               __vst1q_lane_p8
#define vst1q_lane_s16              __vst1q_lane_s16
#define vst1q_lane_s32              __vst1q_lane_s32
#define vst1q_lane_s8               __vst1q_lane_s8
#define vst1q_lane_u16              __vst1q_lane_u16
#define vst1q_lane_u32              __vst1q_lane_u32
#define vst1q_lane_u8               __vst1q_lane_u8
#define vst1_lane_f32_ex            __vst1_lane_f32_ex
#define vst1_lane_p16_ex            __vst1_lane_p16_ex
#define vst1_lane_s16_ex            __vst1_lane_s16_ex
#define vst1_lane_s32_ex            __vst1_lane_s32_ex
#define vst1_lane_u16_ex            __vst1_lane_u16_ex
#define vst1_lane_u32_ex            __vst1_lane_u32_ex
#define vst1q_lane_f32_ex           __vst1q_lane_f32_ex
#define vst1q_lane_p16_ex           __vst1q_lane_p16_ex
#define vst1q_lane_s16_ex           __vst1q_lane_s16_ex
#define vst1q_lane_s32_ex           __vst1q_lane_s32_ex
#define vst1q_lane_u16_ex           __vst1q_lane_u16_ex
#define vst1q_lane_u32_ex           __vst1q_lane_u32_ex
#define vst2_f32                    __vst2_f32
#define vst2_p16                    __vst2_p16
#define vst2_p8                     __vst2_p8
#define vst2_s16                    __vst2_s16
#define vst2_s32                    __vst2_s32
#define vst2_s8                     __vst2_s8
#define vst2_u16                    __vst2_u16
#define vst2_u32                    __vst2_u32
#define vst2_u8                     __vst2_u8
#define vst2_s64                    __vst2_s64
#define vst2_u64                    __vst2_u64
#define vst2_s64_ex                 __vst2_s64_ex
#define vst2_u64_ex                 __vst2_u64_ex
#define vst2_f32_ex                 __vst2_f32_ex
#define vst2_p16_ex                 __vst2_p16_ex
#define vst2_p8_ex                  __vst2_p8_ex
#define vst2_s16_ex                 __vst2_s16_ex
#define vst2_s32_ex                 __vst2_s32_ex
#define vst2_s8_ex                  __vst2_s8_ex
#define vst2_u16_ex                 __vst2_u16_ex
#define vst2_u32_ex                 __vst2_u32_ex
#define vst2_u8_ex                  __vst2_u8_ex
#define vst2q_f32                   __vst2q_f32
#define vst2q_p16                   __vst2q_p16
#define vst2q_p8                    __vst2q_p8
#define vst2q_s16                   __vst2q_s16
#define vst2q_s32                   __vst2q_s32
#define vst2q_s8                    __vst2q_s8
#define vst2q_u16                   __vst2q_u16
#define vst2q_u32                   __vst2q_u32
#define vst2q_u8                    __vst2q_u8
#define vst2q_f32_ex                __vst2q_f32_ex
#define vst2q_p16_ex                __vst2q_p16_ex
#define vst2q_p8_ex                 __vst2q_p8_ex
#define vst2q_s16_ex                __vst2q_s16_ex
#define vst2q_s32_ex                __vst2q_s32_ex
#define vst2q_s8_ex                 __vst2q_s8_ex
#define vst2q_u16_ex                __vst2q_u16_ex
#define vst2q_u32_ex                __vst2q_u32_ex
#define vst2q_u8_ex                 __vst2q_u8_ex
#define vst2_lane_f32               __vst2_lane_f32
#define vst2_lane_p16               __vst2_lane_p16
#define vst2_lane_p8                __vst2_lane_p8
#define vst2_lane_s16               __vst2_lane_s16
#define vst2_lane_s32               __vst2_lane_s32
#define vst2_lane_s8                __vst2_lane_s8
#define vst2_lane_u16               __vst2_lane_u16
#define vst2_lane_u32               __vst2_lane_u32
#define vst2_lane_u8                __vst2_lane_u8
#define vst2q_lane_f32              __vst2q_lane_f32
#define vst2q_lane_p16              __vst2q_lane_p16
#define vst2q_lane_s16              __vst2q_lane_s16
#define vst2q_lane_s32              __vst2q_lane_s32
#define vst2q_lane_u16              __vst2q_lane_u16
#define vst2q_lane_u32              __vst2q_lane_u32
#define vst2_lane_f32_ex            __vst2_lane_f32_ex
#define vst2_lane_p16_ex            __vst2_lane_p16_ex
#define vst2_lane_p8_ex             __vst2_lane_p8_ex
#define vst2_lane_s16_ex            __vst2_lane_s16_ex
#define vst2_lane_s32_ex            __vst2_lane_s32_ex
#define vst2_lane_s8_ex             __vst2_lane_s8_ex
#define vst2_lane_u16_ex            __vst2_lane_u16_ex
#define vst2_lane_u32_ex            __vst2_lane_u32_ex
#define vst2_lane_u8_ex             __vst2_lane_u8_ex
#define vst2q_lane_f32_ex           __vst2q_lane_f32_ex
#define vst2q_lane_p16_ex           __vst2q_lane_p16_ex
#define vst2q_lane_s16_ex           __vst2q_lane_s16_ex
#define vst2q_lane_s32_ex           __vst2q_lane_s32_ex
#define vst2q_lane_u16_ex           __vst2q_lane_u16_ex
#define vst2q_lane_u32_ex           __vst2q_lane_u32_ex
#define vst3_f32                    __vst3_f32
#define vst3_p16                    __vst3_p16
#define vst3_p8                     __vst3_p8
#define vst3_s16                    __vst3_s16
#define vst3_s32                    __vst3_s32
#define vst3_s8                     __vst3_s8
#define vst3_u16                    __vst3_u16
#define vst3_u32                    __vst3_u32
#define vst3_u8                     __vst3_u8
#define vst3_s64                    __vst3_s64
#define vst3_u64                    __vst3_u64
#define vst3_s64_ex                 __vst3_s64_ex
#define vst3_u64_ex                 __vst3_u64_ex
#define vst3_f32_ex                 __vst3_f32_ex
#define vst3_p16_ex                 __vst3_p16_ex
#define vst3_p8_ex                  __vst3_p8_ex
#define vst3_s16_ex                 __vst3_s16_ex
#define vst3_s32_ex                 __vst3_s32_ex
#define vst3_s8_ex                  __vst3_s8_ex
#define vst3_u16_ex                 __vst3_u16_ex
#define vst3_u32_ex                 __vst3_u32_ex
#define vst3_u8_ex                  __vst3_u8_ex
#define vst3q_f32                   __vst3q_f32
#define vst3q_p16                   __vst3q_p16
#define vst3q_p8                    __vst3q_p8
#define vst3q_s16                   __vst3q_s16
#define vst3q_s32                   __vst3q_s32
#define vst3q_s8                    __vst3q_s8
#define vst3q_u16                   __vst3q_u16
#define vst3q_u32                   __vst3q_u32
#define vst3q_u8                    __vst3q_u8
#define vst3q_f32_ex                __vst3q_f32_ex
#define vst3q_p16_ex                __vst3q_p16_ex
#define vst3q_p8_ex                 __vst3q_p8_ex
#define vst3q_s16_ex                __vst3q_s16_ex
#define vst3q_s32_ex                __vst3q_s32_ex
#define vst3q_s8_ex                 __vst3q_s8_ex
#define vst3q_u16_ex                __vst3q_u16_ex
#define vst3q_u32_ex                __vst3q_u32_ex
#define vst3q_u8_ex                 __vst3q_u8_ex
#define vst3_lane_f32               __vst3_lane_f32
#define vst3_lane_p16               __vst3_lane_p16
#define vst3_lane_p8                __vst3_lane_p8
#define vst3_lane_s16               __vst3_lane_s16
#define vst3_lane_s32               __vst3_lane_s32
#define vst3_lane_s8                __vst3_lane_s8
#define vst3_lane_u16               __vst3_lane_u16
#define vst3_lane_u32               __vst3_lane_u32
#define vst3_lane_u8                __vst3_lane_u8
#define vst3q_lane_f32              __vst3q_lane_f32
#define vst3q_lane_p16              __vst3q_lane_p16
#define vst3q_lane_s16              __vst3q_lane_s16
#define vst3q_lane_s32              __vst3q_lane_s32
#define vst3q_lane_u16              __vst3q_lane_u16
#define vst3q_lane_u32              __vst3q_lane_u32
#define vst4_f32                    __vst4_f32
#define vst4_p16                    __vst4_p16
#define vst4_p8                     __vst4_p8
#define vst4_s16                    __vst4_s16
#define vst4_s32                    __vst4_s32
#define vst4_s8                     __vst4_s8
#define vst4_u16                    __vst4_u16
#define vst4_u32                    __vst4_u32
#define vst4_u8                     __vst4_u8
#define vst4_s64                    __vst4_s64
#define vst4_u64                    __vst4_u64
#define vst4_s64_ex                 __vst4_s64_ex
#define vst4_u64_ex                 __vst4_u64_ex
#define vst4_f32_ex                 __vst4_f32_ex
#define vst4_p16_ex                 __vst4_p16_ex
#define vst4_p8_ex                  __vst4_p8_ex
#define vst4_s16_ex                 __vst4_s16_ex
#define vst4_s32_ex                 __vst4_s32_ex
#define vst4_s8_ex                  __vst4_s8_ex
#define vst4_u16_ex                 __vst4_u16_ex
#define vst4_u32_ex                 __vst4_u32_ex
#define vst4_u8_ex                  __vst4_u8_ex
#define vst4q_f32                   __vst4q_f32
#define vst4q_p16                   __vst4q_p16
#define vst4q_p8                    __vst4q_p8
#define vst4q_s16                   __vst4q_s16
#define vst4q_s32                   __vst4q_s32
#define vst4q_s8                    __vst4q_s8
#define vst4q_u16                   __vst4q_u16
#define vst4q_u32                   __vst4q_u32
#define vst4q_u8                    __vst4q_u8
#define vst4q_f32_ex                __vst4q_f32_ex
#define vst4q_p16_ex                __vst4q_p16_ex
#define vst4q_p8_ex                 __vst4q_p8_ex
#define vst4q_s16_ex                __vst4q_s16_ex
#define vst4q_s32_ex                __vst4q_s32_ex
#define vst4q_s8_ex                 __vst4q_s8_ex
#define vst4q_u16_ex                __vst4q_u16_ex
#define vst4q_u32_ex                __vst4q_u32_ex
#define vst4q_u8_ex                 __vst4q_u8_ex
#define vst4_lane_f32               __vst4_lane_f32
#define vst4_lane_p16               __vst4_lane_p16
#define vst4_lane_p8                __vst4_lane_p8
#define vst4_lane_s16               __vst4_lane_s16
#define vst4_lane_s32               __vst4_lane_s32
#define vst4_lane_s8                __vst4_lane_s8
#define vst4_lane_u16               __vst4_lane_u16
#define vst4_lane_u32               __vst4_lane_u32
#define vst4_lane_u8                __vst4_lane_u8
#define vst4q_lane_f32              __vst4q_lane_f32
#define vst4q_lane_p16              __vst4q_lane_p16
#define vst4q_lane_s16              __vst4q_lane_s16
#define vst4q_lane_s32              __vst4q_lane_s32
#define vst4q_lane_u16              __vst4q_lane_u16
#define vst4q_lane_u32              __vst4q_lane_u32
#define vst4_lane_f32_ex            __vst4_lane_f32_ex
#define vst4_lane_p16_ex            __vst4_lane_p16_ex
#define vst4_lane_p8_ex             __vst4_lane_p8_ex
#define vst4_lane_s16_ex            __vst4_lane_s16_ex
#define vst4_lane_s32_ex            __vst4_lane_s32_ex
#define vst4_lane_s8_ex             __vst4_lane_s8_ex
#define vst4_lane_u16_ex            __vst4_lane_u16_ex
#define vst4_lane_u32_ex            __vst4_lane_u32_ex
#define vst4_lane_u8_ex             __vst4_lane_u8_ex
#define vst4q_lane_f32_ex           __vst4q_lane_f32_ex
#define vst4q_lane_p16_ex           __vst4q_lane_p16_ex
#define vst4q_lane_s16_ex           __vst4q_lane_s16_ex
#define vst4q_lane_s32_ex           __vst4q_lane_s32_ex
#define vst4q_lane_u16_ex           __vst4q_lane_u16_ex
#define vst4q_lane_u32_ex           __vst4q_lane_u32_ex
#define vsub_f32                    __vsub_f32
#define vsub_s16                    __vsub_s16
#define vsub_s32                    __vsub_s32
#define vsub_s64                    __vsub_s64
#define vsub_s8                     __vsub_s8
#define vsub_u16                    __vsub_u16
#define vsub_u32                    __vsub_u32
#define vsub_u64                    __vsub_u64
#define vsub_u8                     __vsub_u8
#define vsubq_f32                   __vsubq_f32
#define vsubq_s16                   __vsubq_s16
#define vsubq_s32                   __vsubq_s32
#define vsubq_s64                   __vsubq_s64
#define vsubq_s8                    __vsubq_s8
#define vsubq_u16                   __vsubq_u16
#define vsubq_u32                   __vsubq_u32
#define vsubq_u64                   __vsubq_u64
#define vsubq_u8                    __vsubq_u8
#define vrsubhn_s16                 __vrsubhn_s16
#define vrsubhn_s32                 __vrsubhn_s32
#define vrsubhn_s64                 __vrsubhn_s64
#define vrsubhn_u16                 __vrsubhn_u16
#define vrsubhn_u32                 __vrsubhn_u32
#define vrsubhn_u64                 __vrsubhn_u64
#define vsubhn_s16                  __vsubhn_s16
#define vsubhn_s32                  __vsubhn_s32
#define vsubhn_s64                  __vsubhn_s64
#define vsubhn_u16                  __vsubhn_u16
#define vsubhn_u32                  __vsubhn_u32
#define vsubhn_u64                  __vsubhn_u64
#define vsubl_s16                   __vsubl_s16
#define vsubl_s32                   __vsubl_s32
#define vsubl_s8                    __vsubl_s8
#define vsubl_u16                   __vsubl_u16
#define vsubl_u32                   __vsubl_u32
#define vsubl_u8                    __vsubl_u8
#define vsubw_s16                   __vsubw_s16
#define vsubw_s32                   __vsubw_s32
#define vsubw_s8                    __vsubw_s8
#define vsubw_u16                   __vsubw_u16
#define vsubw_u32                   __vsubw_u32
#define vsubw_u8                    __vsubw_u8
#define vtbl2_p8                    __vtbl2_p8
#define vtbl2_s8                    __vtbl2_s8
#define vtbl2_u8                    __vtbl2_u8
#define vtbx2_p8                    __vtbx2_p8
#define vtbx2_s8                    __vtbx2_s8
#define vtbx2_u8                    __vtbx2_u8
#define vtbl3_p8                    __vtbl3_p8
#define vtbl3_s8                    __vtbl3_s8
#define vtbl3_u8                    __vtbl3_u8
#define vtbx3_p8                    __vtbx3_p8
#define vtbx3_s8                    __vtbx3_s8
#define vtbx3_u8                    __vtbx3_u8
#define vtbl4_p8                    __vtbl4_p8
#define vtbl4_s8                    __vtbl4_s8
#define vtbl4_u8                    __vtbl4_u8
#define vtbx4_p8                    __vtbx4_p8
#define vtbx4_s8                    __vtbx4_s8
#define vtbx4_u8                    __vtbx4_u8
#define vtbl1_p8                    __vtbl1_p8
#define vtbl1_s8                    __vtbl1_s8
#define vtbl1_u8                    __vtbl1_u8
#define vtbx1_p8                    __vtbx1_p8
#define vtbx1_s8                    __vtbx1_s8
#define vtbx1_u8                    __vtbx1_u8
#define vtrn_f32                    __vtrn_f32
#define vtrn_p16                    __vtrn_p16
#define vtrn_p8                     __vtrn_p8
#define vtrn_s16                    __vtrn_s16
#define vtrn_s32                    __vtrn_s32
#define vtrn_s8                     __vtrn_s8
#define vtrn_u16                    __vtrn_u16
#define vtrn_u32                    __vtrn_u32
#define vtrn_u8                     __vtrn_u8
#define vtrnq_f32                   __vtrnq_f32
#define vtrnq_p16                   __vtrnq_p16
#define vtrnq_p8                    __vtrnq_p8
#define vtrnq_s16                   __vtrnq_s16
#define vtrnq_s32                   __vtrnq_s32
#define vtrnq_s8                    __vtrnq_s8
#define vtrnq_u16                   __vtrnq_u16
#define vtrnq_u32                   __vtrnq_u32
#define vtrnq_u8                    __vtrnq_u8
#define vtrnq_s64                   __vtrnq_s64
#define vtrnq_u64                   __vtrnq_u64
#define vtst_p8                     __vtst_p8
#define vtst_s16                    __vtst_s16
#define vtst_s32                    __vtst_s32
#define vtst_s8                     __vtst_s8
#define vtst_u16                    __vtst_u16
#define vtst_u32                    __vtst_u32
#define vtst_u8                     __vtst_u8
#define vtstq_p8                    __vtstq_p8
#define vtstq_s16                   __vtstq_s16
#define vtstq_s32                   __vtstq_s32
#define vtstq_s8                    __vtstq_s8
#define vtstq_u16                   __vtstq_u16
#define vtstq_u32                   __vtstq_u32
#define vtstq_u8                    __vtstq_u8
#define vuzp_p16                    __vuzp_p16
#define vuzp_p8                     __vuzp_p8
#define vuzp_s16                    __vuzp_s16
#define vuzp_s8                     __vuzp_s8
#define vuzp_u16                    __vuzp_u16
#define vuzp_u8                     __vuzp_u8
#define vuzp_f32                    __vuzp_f32
#define vuzp_s32                    __vuzp_s32
#define vuzp_u32                    __vuzp_u32
#define vuzpq_f32                   __vuzpq_f32
#define vuzpq_p16                   __vuzpq_p16
#define vuzpq_p8                    __vuzpq_p8
#define vuzpq_s16                   __vuzpq_s16
#define vuzpq_s32                   __vuzpq_s32
#define vuzpq_s8                    __vuzpq_s8
#define vuzpq_u16                   __vuzpq_u16
#define vuzpq_u32                   __vuzpq_u32
#define vuzpq_u8                    __vuzpq_u8
#define vzip_p16                    __vzip_p16
#define vzip_p8                     __vzip_p8
#define vzip_s16                    __vzip_s16
#define vzip_s8                     __vzip_s8
#define vzip_u16                    __vzip_u16
#define vzip_u8                     __vzip_u8
#define vzip_f32                    __vzip_f32
#define vzip_s32                    __vzip_s32
#define vzip_u32                    __vzip_u32
#define vzipq_f32                   __vzipq_f32
#define vzipq_p16                   __vzipq_p16
#define vzipq_p8                    __vzipq_p8
#define vzipq_s16                   __vzipq_s16
#define vzipq_s32                   __vzipq_s32
#define vzipq_s8                    __vzipq_s8
#define vzipq_u16                   __vzipq_u16
#define vzipq_u32                   __vzipq_u32
#define vzipq_u8                    __vzipq_u8

#define vreinterpret_f32_s8         __vreinterpret_f32_s8
#define vreinterpret_f32_s16        __vreinterpret_f32_s16
#define vreinterpret_f32_s32        __vreinterpret_f32_s32
#define vreinterpret_f32_s64        __vreinterpret_f32_s64
#define vreinterpret_f32_p8         __vreinterpret_f32_p8
#define vreinterpret_f32_p16        __vreinterpret_f32_p16
#define vreinterpret_f32_u8         __vreinterpret_f32_u8
#define vreinterpret_f32_u16        __vreinterpret_f32_u16
#define vreinterpret_f32_u32        __vreinterpret_f32_u32
#define vreinterpret_f32_u64        __vreinterpret_f32_u64
#define vreinterpret_s8_f32         __vreinterpret_s8_f32
#define vreinterpret_s8_s16         __vreinterpret_s8_s16
#define vreinterpret_s8_s32         __vreinterpret_s8_s32
#define vreinterpret_s8_s64         __vreinterpret_s8_s64
#define vreinterpret_s8_p8          __vreinterpret_s8_p8
#define vreinterpret_s8_p16         __vreinterpret_s8_p16
#define vreinterpret_s8_u8          __vreinterpret_s8_u8
#define vreinterpret_s8_u16         __vreinterpret_s8_u16
#define vreinterpret_s8_u32         __vreinterpret_s8_u32
#define vreinterpret_s8_u64         __vreinterpret_s8_u64
#define vreinterpret_s16_f32        __vreinterpret_s16_f32
#define vreinterpret_s16_s8         __vreinterpret_s16_s8
#define vreinterpret_s16_s32        __vreinterpret_s16_s32
#define vreinterpret_s16_s64        __vreinterpret_s16_s64
#define vreinterpret_s16_p8         __vreinterpret_s16_p8
#define vreinterpret_s16_p16        __vreinterpret_s16_p16
#define vreinterpret_s16_u8         __vreinterpret_s16_u8
#define vreinterpret_s16_u16        __vreinterpret_s16_u16
#define vreinterpret_s16_u32        __vreinterpret_s16_u32
#define vreinterpret_s16_u64        __vreinterpret_s16_u64
#define vreinterpret_s32_f32        __vreinterpret_s32_f32
#define vreinterpret_s32_s8         __vreinterpret_s32_s8
#define vreinterpret_s32_s16        __vreinterpret_s32_s16
#define vreinterpret_s32_s64        __vreinterpret_s32_s64
#define vreinterpret_s32_p8         __vreinterpret_s32_p8
#define vreinterpret_s32_p16        __vreinterpret_s32_p16
#define vreinterpret_s32_u8         __vreinterpret_s32_u8
#define vreinterpret_s32_u16        __vreinterpret_s32_u16
#define vreinterpret_s32_u32        __vreinterpret_s32_u32
#define vreinterpret_s32_u64        __vreinterpret_s32_u64
#define vreinterpret_s64_f32        __vreinterpret_s64_f32
#define vreinterpret_s64_s8         __vreinterpret_s64_s8
#define vreinterpret_s64_s16        __vreinterpret_s64_s16
#define vreinterpret_s64_s32        __vreinterpret_s64_s32
#define vreinterpret_s64_p8         __vreinterpret_s64_p8
#define vreinterpret_s64_p16        __vreinterpret_s64_p16
#define vreinterpret_s64_u8         __vreinterpret_s64_u8
#define vreinterpret_s64_u16        __vreinterpret_s64_u16
#define vreinterpret_s64_u32        __vreinterpret_s64_u32
#define vreinterpret_s64_u64        __vreinterpret_s64_u64
#define vreinterpret_p8_f32         __vreinterpret_p8_f32
#define vreinterpret_p8_s8          __vreinterpret_p8_s8
#define vreinterpret_p8_s16         __vreinterpret_p8_s16
#define vreinterpret_p8_s32         __vreinterpret_p8_s32
#define vreinterpret_p8_s64         __vreinterpret_p8_s64
#define vreinterpret_p8_p16         __vreinterpret_p8_p16
#define vreinterpret_p8_u8          __vreinterpret_p8_u8
#define vreinterpret_p8_u16         __vreinterpret_p8_u16
#define vreinterpret_p8_u32         __vreinterpret_p8_u32
#define vreinterpret_p8_u64         __vreinterpret_p8_u64
#define vreinterpret_p16_f32        __vreinterpret_p16_f32
#define vreinterpret_p16_s8         __vreinterpret_p16_s8
#define vreinterpret_p16_s16        __vreinterpret_p16_s16
#define vreinterpret_p16_s32        __vreinterpret_p16_s32
#define vreinterpret_p16_s64        __vreinterpret_p16_s64
#define vreinterpret_p16_p8         __vreinterpret_p16_p8
#define vreinterpret_p16_u8         __vreinterpret_p16_u8
#define vreinterpret_p16_u16        __vreinterpret_p16_u16
#define vreinterpret_p16_u32        __vreinterpret_p16_u32
#define vreinterpret_p16_u64        __vreinterpret_p16_u64
#define vreinterpret_u8_f32         __vreinterpret_u8_f32
#define vreinterpret_u8_s8          __vreinterpret_u8_s8
#define vreinterpret_u8_s16         __vreinterpret_u8_s16
#define vreinterpret_u8_s32         __vreinterpret_u8_s32
#define vreinterpret_u8_s64         __vreinterpret_u8_s64
#define vreinterpret_u8_p8          __vreinterpret_u8_p8
#define vreinterpret_u8_p16         __vreinterpret_u8_p16
#define vreinterpret_u8_u16         __vreinterpret_u8_u16
#define vreinterpret_u8_u32         __vreinterpret_u8_u32
#define vreinterpret_u8_u64         __vreinterpret_u8_u64
#define vreinterpret_u16_f32        __vreinterpret_u16_f32
#define vreinterpret_u16_s8         __vreinterpret_u16_s8
#define vreinterpret_u16_s16        __vreinterpret_u16_s16
#define vreinterpret_u16_s32        __vreinterpret_u16_s32
#define vreinterpret_u16_s64        __vreinterpret_u16_s64
#define vreinterpret_u16_p8         __vreinterpret_u16_p8
#define vreinterpret_u16_p16        __vreinterpret_u16_p16
#define vreinterpret_u16_u8         __vreinterpret_u16_u8
#define vreinterpret_u16_u32        __vreinterpret_u16_u32
#define vreinterpret_u16_u64        __vreinterpret_u16_u64
#define vreinterpret_u32_f32        __vreinterpret_u32_f32
#define vreinterpret_u32_s8         __vreinterpret_u32_s8
#define vreinterpret_u32_s16        __vreinterpret_u32_s16
#define vreinterpret_u32_s32        __vreinterpret_u32_s32
#define vreinterpret_u32_s64        __vreinterpret_u32_s64
#define vreinterpret_u32_p8         __vreinterpret_u32_p8
#define vreinterpret_u32_p16        __vreinterpret_u32_p16
#define vreinterpret_u32_u8         __vreinterpret_u32_u8
#define vreinterpret_u32_u16        __vreinterpret_u32_u16
#define vreinterpret_u32_u64        __vreinterpret_u32_u64
#define vreinterpret_u64_f32        __vreinterpret_u64_f32
#define vreinterpret_u64_s8         __vreinterpret_u64_s8
#define vreinterpret_u64_s16        __vreinterpret_u64_s16
#define vreinterpret_u64_s32        __vreinterpret_u64_s32
#define vreinterpret_u64_s64        __vreinterpret_u64_s64
#define vreinterpret_u64_p8         __vreinterpret_u64_p8
#define vreinterpret_u64_p16        __vreinterpret_u64_p16
#define vreinterpret_u64_u8         __vreinterpret_u64_u8
#define vreinterpret_u64_u16        __vreinterpret_u64_u16
#define vreinterpret_u64_u32        __vreinterpret_u64_u32
#define vreinterpretq_f32_s8        __vreinterpretq_f32_s8
#define vreinterpretq_f32_s16       __vreinterpretq_f32_s16
#define vreinterpretq_f32_s32       __vreinterpretq_f32_s32
#define vreinterpretq_f32_s64       __vreinterpretq_f32_s64
#define vreinterpretq_f32_p8        __vreinterpretq_f32_p8
#define vreinterpretq_f32_p16       __vreinterpretq_f32_p16
#define vreinterpretq_f32_u8        __vreinterpretq_f32_u8
#define vreinterpretq_f32_u16       __vreinterpretq_f32_u16
#define vreinterpretq_f32_u32       __vreinterpretq_f32_u32
#define vreinterpretq_f32_u64       __vreinterpretq_f32_u64
#define vreinterpretq_s8_f32        __vreinterpretq_s8_f32
#define vreinterpretq_s8_s16        __vreinterpretq_s8_s16
#define vreinterpretq_s8_s32        __vreinterpretq_s8_s32
#define vreinterpretq_s8_s64        __vreinterpretq_s8_s64
#define vreinterpretq_s8_p8         __vreinterpretq_s8_p8
#define vreinterpretq_s8_p16        __vreinterpretq_s8_p16
#define vreinterpretq_s8_u8         __vreinterpretq_s8_u8
#define vreinterpretq_s8_u16        __vreinterpretq_s8_u16
#define vreinterpretq_s8_u32        __vreinterpretq_s8_u32
#define vreinterpretq_s8_u64        __vreinterpretq_s8_u64
#define vreinterpretq_s16_f32       __vreinterpretq_s16_f32
#define vreinterpretq_s16_s8        __vreinterpretq_s16_s8
#define vreinterpretq_s16_s32       __vreinterpretq_s16_s32
#define vreinterpretq_s16_s64       __vreinterpretq_s16_s64
#define vreinterpretq_s16_p8        __vreinterpretq_s16_p8
#define vreinterpretq_s16_p16       __vreinterpretq_s16_p16
#define vreinterpretq_s16_u8        __vreinterpretq_s16_u8
#define vreinterpretq_s16_u16       __vreinterpretq_s16_u16
#define vreinterpretq_s16_u32       __vreinterpretq_s16_u32
#define vreinterpretq_s16_u64       __vreinterpretq_s16_u64
#define vreinterpretq_s32_f32       __vreinterpretq_s32_f32
#define vreinterpretq_s32_s8        __vreinterpretq_s32_s8
#define vreinterpretq_s32_s16       __vreinterpretq_s32_s16
#define vreinterpretq_s32_s64       __vreinterpretq_s32_s64
#define vreinterpretq_s32_p8        __vreinterpretq_s32_p8
#define vreinterpretq_s32_p16       __vreinterpretq_s32_p16
#define vreinterpretq_s32_u8        __vreinterpretq_s32_u8
#define vreinterpretq_s32_u16       __vreinterpretq_s32_u16
#define vreinterpretq_s32_u32       __vreinterpretq_s32_u32
#define vreinterpretq_s32_u64       __vreinterpretq_s32_u64
#define vreinterpretq_s64_f32       __vreinterpretq_s64_f32
#define vreinterpretq_s64_s8        __vreinterpretq_s64_s8
#define vreinterpretq_s64_s16       __vreinterpretq_s64_s16
#define vreinterpretq_s64_s32       __vreinterpretq_s64_s32
#define vreinterpretq_s64_p8        __vreinterpretq_s64_p8
#define vreinterpretq_s64_p16       __vreinterpretq_s64_p16
#define vreinterpretq_s64_u8        __vreinterpretq_s64_u8
#define vreinterpretq_s64_u16       __vreinterpretq_s64_u16
#define vreinterpretq_s64_u32       __vreinterpretq_s64_u32
#define vreinterpretq_s64_u64       __vreinterpretq_s64_u64
#define vreinterpretq_p8_f32        __vreinterpretq_p8_f32
#define vreinterpretq_p8_s8         __vreinterpretq_p8_s8
#define vreinterpretq_p8_s16        __vreinterpretq_p8_s16
#define vreinterpretq_p8_s32        __vreinterpretq_p8_s32
#define vreinterpretq_p8_s64        __vreinterpretq_p8_s64
#define vreinterpretq_p8_p16        __vreinterpretq_p8_p16
#define vreinterpretq_p8_u8         __vreinterpretq_p8_u8
#define vreinterpretq_p8_u16        __vreinterpretq_p8_u16
#define vreinterpretq_p8_u32        __vreinterpretq_p8_u32
#define vreinterpretq_p8_u64        __vreinterpretq_p8_u64
#define vreinterpretq_p16_f32       __vreinterpretq_p16_f32
#define vreinterpretq_p16_s8        __vreinterpretq_p16_s8
#define vreinterpretq_p16_s16       __vreinterpretq_p16_s16
#define vreinterpretq_p16_s32       __vreinterpretq_p16_s32
#define vreinterpretq_p16_s64       __vreinterpretq_p16_s64
#define vreinterpretq_p16_p8        __vreinterpretq_p16_p8
#define vreinterpretq_p16_u8        __vreinterpretq_p16_u8
#define vreinterpretq_p16_u16       __vreinterpretq_p16_u16
#define vreinterpretq_p16_u32       __vreinterpretq_p16_u32
#define vreinterpretq_p16_u64       __vreinterpretq_p16_u64
#define vreinterpretq_u8_f32        __vreinterpretq_u8_f32
#define vreinterpretq_u8_s8         __vreinterpretq_u8_s8
#define vreinterpretq_u8_s16        __vreinterpretq_u8_s16
#define vreinterpretq_u8_s32        __vreinterpretq_u8_s32
#define vreinterpretq_u8_s64        __vreinterpretq_u8_s64
#define vreinterpretq_u8_p8         __vreinterpretq_u8_p8
#define vreinterpretq_u8_p16        __vreinterpretq_u8_p16
#define vreinterpretq_u8_u16        __vreinterpretq_u8_u16
#define vreinterpretq_u8_u32        __vreinterpretq_u8_u32
#define vreinterpretq_u8_u64        __vreinterpretq_u8_u64
#define vreinterpretq_u16_f32       __vreinterpretq_u16_f32
#define vreinterpretq_u16_s8        __vreinterpretq_u16_s8
#define vreinterpretq_u16_s16       __vreinterpretq_u16_s16
#define vreinterpretq_u16_s32       __vreinterpretq_u16_s32
#define vreinterpretq_u16_s64       __vreinterpretq_u16_s64
#define vreinterpretq_u16_p8        __vreinterpretq_u16_p8
#define vreinterpretq_u16_p16       __vreinterpretq_u16_p16
#define vreinterpretq_u16_u8        __vreinterpretq_u16_u8
#define vreinterpretq_u16_u32       __vreinterpretq_u16_u32
#define vreinterpretq_u16_u64       __vreinterpretq_u16_u64
#define vreinterpretq_u32_f32       __vreinterpretq_u32_f32
#define vreinterpretq_u32_s8        __vreinterpretq_u32_s8
#define vreinterpretq_u32_s16       __vreinterpretq_u32_s16
#define vreinterpretq_u32_s32       __vreinterpretq_u32_s32
#define vreinterpretq_u32_s64       __vreinterpretq_u32_s64
#define vreinterpretq_u32_p8        __vreinterpretq_u32_p8
#define vreinterpretq_u32_p16       __vreinterpretq_u32_p16
#define vreinterpretq_u32_u8        __vreinterpretq_u32_u8
#define vreinterpretq_u32_u16       __vreinterpretq_u32_u16
#define vreinterpretq_u32_u64       __vreinterpretq_u32_u64
#define vreinterpretq_u64_f32       __vreinterpretq_u64_f32
#define vreinterpretq_u64_s8        __vreinterpretq_u64_s8
#define vreinterpretq_u64_s16       __vreinterpretq_u64_s16
#define vreinterpretq_u64_s32       __vreinterpretq_u64_s32
#define vreinterpretq_u64_s64       __vreinterpretq_u64_s64
#define vreinterpretq_u64_p8        __vreinterpretq_u64_p8
#define vreinterpretq_u64_p16       __vreinterpretq_u64_p16
#define vreinterpretq_u64_u8        __vreinterpretq_u64_u8
#define vreinterpretq_u64_u16       __vreinterpretq_u64_u16
#define vreinterpretq_u64_u32       __vreinterpretq_u64_u32

#define vmul_n_s16                  __vmul_n_s16
#define vmul_n_s32                  __vmul_n_s32
#define vmul_n_u16                  __vmul_n_u16
#define vmul_n_u32                  __vmul_n_u32
#define vmulq_n_s16                 __vmulq_n_s16
#define vmulq_n_s32                 __vmulq_n_s32
#define vmulq_n_u16                 __vmulq_n_u16
#define vmulq_n_u32                 __vmulq_n_u32
#define vmull_n_s16                 __vmull_n_s16
#define vmull_n_s32                 __vmull_n_s32
#define vmull_n_u16                 __vmull_n_u16
#define vmull_n_u32                 __vmull_n_u32
#define vqdmulh_n_s16               __vqdmulh_n_s16
#define vqdmulh_n_s32               __vqdmulh_n_s32
#define vqdmulhq_n_s16              __vqdmulhq_n_s16
#define vqdmulhq_n_s32              __vqdmulhq_n_s32
#define vqdmull_n_s16               __vqdmull_n_s16
#define vqdmull_n_s32               __vqdmull_n_s32
#define vqrdmulh_n_s16              __vqrdmulh_n_s16
#define vqrdmulh_n_s32              __vqrdmulh_n_s32
#define vqrdmulhq_n_s16             __vqrdmulhq_n_s16
#define vqrdmulhq_n_s32             __vqrdmulhq_n_s32

#define vmla_n_s16                  __vmla_n_s16
#define vmla_n_s32                  __vmla_n_s32
#define vmla_n_u16                  __vmla_n_u16
#define vmla_n_u32                  __vmla_n_u32
#define vmlaq_n_s16                 __vmlaq_n_s16
#define vmlaq_n_s32                 __vmlaq_n_s32
#define vmlaq_n_u16                 __vmlaq_n_u16
#define vmlaq_n_u32                 __vmlaq_n_u32
#define vmlal_n_s16                 __vmlal_n_s16
#define vmlal_n_s32                 __vmlal_n_s32
#define vmlal_n_u16                 __vmlal_n_u16
#define vmlal_n_u32                 __vmlal_n_u32
#define vmls_n_s16                  __vmls_n_s16
#define vmls_n_s32                  __vmls_n_s32
#define vmls_n_u16                  __vmls_n_u16
#define vmls_n_u32                  __vmls_n_u32
#define vmlsq_n_s16                 __vmlsq_n_s16
#define vmlsq_n_s32                 __vmlsq_n_s32
#define vmlsq_n_u16                 __vmlsq_n_u16
#define vmlsq_n_u32                 __vmlsq_n_u32
#define vmlsl_n_s16                 __vmlsl_n_s16
#define vmlsl_n_s32                 __vmlsl_n_s32
#define vmlsl_n_u16                 __vmlsl_n_u16
#define vmlsl_n_u32                 __vmlsl_n_u32
#define vqdmlal_n_s16               __vqdmlal_n_s16
#define vqdmlal_n_s32               __vqdmlal_n_s32
#define vqdmlsl_n_s16               __vqdmlsl_n_s16
#define vqdmlsl_n_s32               __vqdmlsl_n_s32

#define vdup_lane_s64               __vdup_lane_s64
#define vdup_lane_u64               __vdup_lane_u64
#define vdupq_lane_s64              __vdupq_lane_s64
#define vdupq_lane_u64              __vdupq_lane_u64

#endif // !defined(_ARM_ISO_COMPATIBLE_INTRINSIC_NAMES)

#if defined (__cplusplus)
}
#endif  /* defined (__cplusplus) */

#endif
