#![allow(unused)]

use std::collections::HashMap;

use serde::Deserialize;

struct Function {
    name: &'static str,
    arguments: &'static [&'static Type],
    ret: Option<&'static Type>,
    target_feature: Option<&'static str>,
    instrs: &'static [&'static str],
    file: &'static str,
    required_const: &'static [usize],
    has_test: bool,
    doc: &'static str,
}

static BOOL: Type = Type::PrimBool;
static F16: Type = Type::PrimFloat(16);
static F32: Type = Type::PrimFloat(32);
static F64: Type = Type::PrimFloat(64);
static I16: Type = Type::PrimSigned(16);
static I32: Type = Type::PrimSigned(32);
static I64: Type = Type::PrimSigned(64);
static I8: Type = Type::PrimSigned(8);
static U16: Type = Type::PrimUnsigned(16);
static U32: Type = Type::PrimUnsigned(32);
static U64: Type = Type::PrimUnsigned(64);
static U8: Type = Type::PrimUnsigned(8);
static NEVER: Type = Type::Never;
static VOID: Type = Type::Void;
static GENERICT: Type = Type::GenericParam("T");
static GENERICU: Type = Type::GenericParam("U");

static F16X4: Type = Type::F(16, 4, 1);
static F16X4X2: Type = Type::F(16, 4, 2);
static F16X4X3: Type = Type::F(16, 4, 3);
static F16X4X4: Type = Type::F(16, 4, 4);
static F16X8: Type = Type::F(16, 8, 1);
static F16X8X2: Type = Type::F(16, 8, 2);
static F16X8X3: Type = Type::F(16, 8, 3);
static F16X8X4: Type = Type::F(16, 8, 4);
static F32X2: Type = Type::F(32, 2, 1);
static F32X2X2: Type = Type::F(32, 2, 2);
static F32X2X3: Type = Type::F(32, 2, 3);
static F32X2X4: Type = Type::F(32, 2, 4);
static F32X4: Type = Type::F(32, 4, 1);
static F32X4X2: Type = Type::F(32, 4, 2);
static F32X4X3: Type = Type::F(32, 4, 3);
static F32X4X4: Type = Type::F(32, 4, 4);
static F64X1: Type = Type::F(64, 1, 1);
static F64X1X2: Type = Type::F(64, 1, 2);
static F64X1X3: Type = Type::F(64, 1, 3);
static F64X1X4: Type = Type::F(64, 1, 4);
static F64X2: Type = Type::F(64, 2, 1);
static F64X2X2: Type = Type::F(64, 2, 2);
static F64X2X3: Type = Type::F(64, 2, 3);
static F64X2X4: Type = Type::F(64, 2, 4);
static I16X2: Type = Type::I(16, 2, 1);
static I16X4: Type = Type::I(16, 4, 1);
static I16X4X2: Type = Type::I(16, 4, 2);
static I16X4X3: Type = Type::I(16, 4, 3);
static I16X4X4: Type = Type::I(16, 4, 4);
static I16X8: Type = Type::I(16, 8, 1);
static I16X8X2: Type = Type::I(16, 8, 2);
static I16X8X3: Type = Type::I(16, 8, 3);
static I16X8X4: Type = Type::I(16, 8, 4);
static I32X2: Type = Type::I(32, 2, 1);
static I32X2X2: Type = Type::I(32, 2, 2);
static I32X2X3: Type = Type::I(32, 2, 3);
static I32X2X4: Type = Type::I(32, 2, 4);
static I32X4: Type = Type::I(32, 4, 1);
static I32X4X2: Type = Type::I(32, 4, 2);
static I32X4X3: Type = Type::I(32, 4, 3);
static I32X4X4: Type = Type::I(32, 4, 4);
static I64X1: Type = Type::I(64, 1, 1);
static I64X1X2: Type = Type::I(64, 1, 2);
static I64X1X3: Type = Type::I(64, 1, 3);
static I64X1X4: Type = Type::I(64, 1, 4);
static I64X2: Type = Type::I(64, 2, 1);
static I64X2X2: Type = Type::I(64, 2, 2);
static I64X2X3: Type = Type::I(64, 2, 3);
static I64X2X4: Type = Type::I(64, 2, 4);
static I8X16: Type = Type::I(8, 16, 1);
static I8X16X2: Type = Type::I(8, 16, 2);
static I8X16X3: Type = Type::I(8, 16, 3);
static I8X16X4: Type = Type::I(8, 16, 4);
static I8X4: Type = Type::I(8, 4, 1);
static I8X8: Type = Type::I(8, 8, 1);
static I8X8X2: Type = Type::I(8, 8, 2);
static I8X8X3: Type = Type::I(8, 8, 3);
static I8X8X4: Type = Type::I(8, 8, 4);
static P128: Type = Type::PrimPoly(128);
static P16: Type = Type::PrimPoly(16);
static P16X4X2: Type = Type::P(16, 4, 2);
static P16X4X3: Type = Type::P(16, 4, 3);
static P16X4X4: Type = Type::P(16, 4, 4);
static P16X8X2: Type = Type::P(16, 8, 2);
static P16X8X3: Type = Type::P(16, 8, 3);
static P16X8X4: Type = Type::P(16, 8, 4);
static P64: Type = Type::PrimPoly(64);
static P64X1X2: Type = Type::P(64, 1, 2);
static P64X1X3: Type = Type::P(64, 1, 3);
static P64X1X4: Type = Type::P(64, 1, 4);
static P64X2X2: Type = Type::P(64, 2, 2);
static P64X2X3: Type = Type::P(64, 2, 3);
static P64X2X4: Type = Type::P(64, 2, 4);
static P8: Type = Type::PrimPoly(8);
static POLY16X4: Type = Type::P(16, 4, 1);
static POLY16X8: Type = Type::P(16, 8, 1);
static POLY64X1: Type = Type::P(64, 1, 1);
static POLY64X2: Type = Type::P(64, 2, 1);
static POLY8X16: Type = Type::P(8, 16, 1);
static POLY8X16X2: Type = Type::P(8, 16, 2);
static POLY8X16X3: Type = Type::P(8, 16, 3);
static POLY8X16X4: Type = Type::P(8, 16, 4);
static POLY8X8: Type = Type::P(8, 8, 1);
static POLY8X8X2: Type = Type::P(8, 8, 2);
static POLY8X8X3: Type = Type::P(8, 8, 3);
static POLY8X8X4: Type = Type::P(8, 8, 4);
static U16X4: Type = Type::U(16, 4, 1);
static U16X4X2: Type = Type::U(16, 4, 2);
static U16X4X3: Type = Type::U(16, 4, 3);
static U16X4X4: Type = Type::U(16, 4, 4);
static U16X8: Type = Type::U(16, 8, 1);
static U16X8X2: Type = Type::U(16, 8, 2);
static U16X8X3: Type = Type::U(16, 8, 3);
static U16X8X4: Type = Type::U(16, 8, 4);
static U32X2: Type = Type::U(32, 2, 1);
static U32X2X2: Type = Type::U(32, 2, 2);
static U32X2X3: Type = Type::U(32, 2, 3);
static U32X2X4: Type = Type::U(32, 2, 4);
static U32X4: Type = Type::U(32, 4, 1);
static U32X4X2: Type = Type::U(32, 4, 2);
static U32X4X3: Type = Type::U(32, 4, 3);
static U32X4X4: Type = Type::U(32, 4, 4);
static U64X1: Type = Type::U(64, 1, 1);
static U64X1X2: Type = Type::U(64, 1, 2);
static U64X1X3: Type = Type::U(64, 1, 3);
static U64X1X4: Type = Type::U(64, 1, 4);
static U64X2: Type = Type::U(64, 2, 1);
static U64X2X2: Type = Type::U(64, 2, 2);
static U64X2X3: Type = Type::U(64, 2, 3);
static U64X2X4: Type = Type::U(64, 2, 4);
static U8X16: Type = Type::U(8, 16, 1);
static U8X16X2: Type = Type::U(8, 16, 2);
static U8X16X3: Type = Type::U(8, 16, 3);
static U8X16X4: Type = Type::U(8, 16, 4);
static U8X8: Type = Type::U(8, 8, 1);
static U8X4: Type = Type::U(8, 4, 1);
static U8X8X2: Type = Type::U(8, 8, 2);
static U8X8X3: Type = Type::U(8, 8, 3);
static U8X8X4: Type = Type::U(8, 8, 4);

static SVBOOL: Type = Type::Pred(1);
static SVBOOLX2: Type = Type::Pred(2);
static SVBOOLX3: Type = Type::Pred(3);
static SVBOOLX4: Type = Type::Pred(4);
static SVCOUNT: Type = Type::Pred(1);
static SVF16: Type = Type::SVF(16, 1);
static SVF16X2: Type = Type::SVF(16, 2);
static SVF16X3: Type = Type::SVF(16, 3);
static SVF16X4: Type = Type::SVF(16, 4);
static SVF32: Type = Type::SVF(32, 1);
static SVF32X2: Type = Type::SVF(32, 2);
static SVF32X3: Type = Type::SVF(32, 3);
static SVF32X4: Type = Type::SVF(32, 4);
static SVF64: Type = Type::SVF(64, 1);
static SVF64X2: Type = Type::SVF(64, 2);
static SVF64X3: Type = Type::SVF(64, 3);
static SVF64X4: Type = Type::SVF(64, 4);
static SVI8: Type = Type::SVI(8, 1);
static SVI8X2: Type = Type::SVI(8, 2);
static SVI8X3: Type = Type::SVI(8, 3);
static SVI8X4: Type = Type::SVI(8, 4);
static SVI16: Type = Type::SVI(16, 1);
static SVI16X2: Type = Type::SVI(16, 2);
static SVI16X3: Type = Type::SVI(16, 3);
static SVI16X4: Type = Type::SVI(16, 4);
static SVI32: Type = Type::SVI(32, 1);
static SVI32X2: Type = Type::SVI(32, 2);
static SVI32X3: Type = Type::SVI(32, 3);
static SVI32X4: Type = Type::SVI(32, 4);
static SVI64: Type = Type::SVI(64, 1);
static SVI64X2: Type = Type::SVI(64, 2);
static SVI64X3: Type = Type::SVI(64, 3);
static SVI64X4: Type = Type::SVI(64, 4);
static SVU8: Type = Type::SVU(8, 1);
static SVU8X2: Type = Type::SVU(8, 2);
static SVU8X3: Type = Type::SVU(8, 3);
static SVU8X4: Type = Type::SVU(8, 4);
static SVU16: Type = Type::SVU(16, 1);
static SVU16X2: Type = Type::SVU(16, 2);
static SVU16X3: Type = Type::SVU(16, 3);
static SVU16X4: Type = Type::SVU(16, 4);
static SVU32: Type = Type::SVU(32, 1);
static SVU32X2: Type = Type::SVU(32, 2);
static SVU32X3: Type = Type::SVU(32, 3);
static SVU32X4: Type = Type::SVU(32, 4);
static SVU64: Type = Type::SVU(64, 1);
static SVU64X2: Type = Type::SVU(64, 2);
static SVU64X3: Type = Type::SVU(64, 3);
static SVU64X4: Type = Type::SVU(64, 4);
static SVPRFOP: Type = Type::Enum("svprfop");
static SVPATTERN: Type = Type::Enum("svpattern");

#[derive(Debug, Copy, Clone, PartialEq)]
enum Type {
    Void,
    PrimBool,
    PrimFloat(u8),
    PrimSigned(u8),
    PrimUnsigned(u8),
    PrimPoly(u8),
    MutPtr(&'static Type),
    ConstPtr(&'static Type),
    Enum(&'static str),
    GenericParam(&'static str),
    I(u8, u8, u8),
    U(u8, u8, u8),
    P(u8, u8, u8),
    F(u8, u8, u8),
    Pred(u8),
    SVI(u8, u8),
    SVU(u8, u8),
    SVF(u8, u8),
    Never,
}

stdarch_verify::arm_functions!(static FUNCTIONS);

macro_rules! bail {
    ($($t:tt)*) => (return Err(format!($($t)*)))
}

#[test]
fn verify_all_signatures() {
    // Reference: https://developer.arm.com/architectures/instruction-sets/intrinsics
    let json = include_bytes!("../../../intrinsics_data/arm_intrinsics.json");
    let intrinsics: Vec<JsonIntrinsic> = serde_json::from_slice(json).unwrap();
    let map = parse_intrinsics(intrinsics);

    let mut all_valid = true;
    for rust in FUNCTIONS {
        // Most SVE intrinsics just rely on the intrinsics test tool for validation
        if !rust.has_test {
            if !SKIP_RUNTIME_TESTS.contains(&rust.name)
                // Most run-time tests are handled by the intrinsic-test tool, except for
                // load/stores (which have generated tests)
                && (!rust.name.starts_with("sv") || rust.name.starts_with("svld")
                    || rust.name.starts_with("svst"))
                // The load/store test generator can't handle these cases yet
                && (!rust.name.contains("_u32base_") || rust.name.contains("index") || rust.name.contains("offset"))
                && !(rust.name.starts_with("svldff1") && rust.name.contains("gather"))
            {
                println!("missing run-time test for `{}`", rust.name);
                all_valid = false;
            }
        }

        // Skip some intrinsics that aren't NEON and are located in different
        // places than the whitelists below.
        match rust.name {
            "brk" | "__breakpoint" | "udf" | "_prefetch" => continue,
            _ => {}
        }
        // Skip some intrinsics that are present in GCC and Clang but
        // are missing from the official documentation.
        let skip_intrinsic_verify = [
            "vmov_n_p64",
            "vmovq_n_p64",
            "vreinterpret_p64_s64",
            "vreinterpret_f32_p64",
            "vreinterpretq_f32_p64",
            "vreinterpretq_p64_p128",
            "vreinterpretq_p128_p64",
            "vreinterpretq_f32_p128",
            "vtst_p16",
            "vtstq_p16",
            "__dbg",
        ];
        let arm = match map.get(rust.name) {
            Some(i) => i,
            None => {
                // Skip all these intrinsics as they're not listed in NEON
                // descriptions online.
                //
                // TODO: we still need to verify these intrinsics or find a
                // reference for them, need to figure out where though!
                if !rust.file.ends_with("dsp.rs\"")
                    && !rust.file.ends_with("sat.rs\"")
                    && !rust.file.ends_with("simd32.rs\"")
                    && !rust.file.ends_with("v6.rs\"")
                    && !rust.file.ends_with("v7.rs\"")
                    && !rust.file.ends_with("v8.rs\"")
                    && !rust.file.ends_with("mte.rs\"")
                    && !rust.file.ends_with("rand.rs\"")
                    && !rust.file.ends_with("ex.rs\"")
                    && !skip_intrinsic_verify.contains(&rust.name)
                {
                    println!(
                        "missing arm definition for {:?} in {}",
                        rust.name, rust.file
                    );
                    all_valid = false;
                }
                continue;
            }
        };

        if let Err(e) = matches(rust, arm) {
            println!("failed to verify `{}`", rust.name);
            println!("  * {e}");
            all_valid = false;
        }
    }
    assert!(all_valid);
}

fn matches(rust: &Function, arm: &Intrinsic) -> Result<(), String> {
    if rust.ret != arm.ret.as_ref() {
        bail!("mismatched return value")
    }
    if rust.arguments.len() != arm.arguments.len() {
        bail!("mismatched argument lengths");
    }

    let mut nconst = 0;
    let iter = rust.arguments.iter().zip(&arm.arguments).enumerate();
    for (i, (rust_ty, (arm, arm_const))) in iter {
        match (*rust_ty, arm) {
            // SVE uses generic type parameters to handle void pointers
            (Type::ConstPtr(Type::GenericParam("T")), Type::ConstPtr(Type::Void)) => (),
            // SVE const generics use i32 over u64 for usability reasons
            (Type::PrimSigned(32), Type::PrimUnsigned(64)) if rust.required_const.contains(&i) => {
                ()
            }
            // svset doesn't have its const argument last as we assumed when building the Function
            _ if rust.name.starts_with("svset") => (),
            (x, y) if x == y => (),
            _ => bail!("mismatched arguments: {rust_ty:?} != {arm:?}"),
        }
        if *arm_const {
            nconst += 1;
            if !rust.required_const.contains(&i) && !rust.name.starts_with("svset") {
                bail!("argument const mismatch");
            }
        }
    }
    if nconst != rust.required_const.len() {
        bail!("wrong number of const arguments");
    }

    if rust.instrs.is_empty()
        && arm.instruction != ""
        && !SKIP_ASSERT_INSTR_TESTS.contains(&rust.name)
    {
        bail!(
            "instruction not listed for `{}`, but arm lists {:?}",
            rust.name,
            arm.instruction
        );
    } else if false
    // TODO: This instruction checking logic needs work to handle multiple instructions and to only
    // look at aarch64 insructions.
    // The ACLE's listed instructions are a guideline only and compilers have the freedom to use
    // different instructions in dfferent cases which makes this an unreliable testing method. It
    // is of questionable value given the intrinsic test tool.
    {
        for instr in rust.instrs {
            if arm.instruction.starts_with(instr) {
                continue;
            }
            // sometimes arm says `foo` and disassemblers say `vfoo`, or
            // sometimes disassemblers say `vfoo` and arm says `sfoo` or `ffoo`
            if instr.starts_with('v')
                && (arm.instruction.starts_with(&instr[1..])
                    || arm.instruction[1..].starts_with(&instr[1..]))
            {
                continue;
            }
            bail!(
                "arm failed to list `{}` as an instruction for `{}` in {:?}",
                instr,
                rust.name,
                arm.instruction,
            );
        }
    }

    // TODO: verify `target_feature`.

    Ok(())
}

#[derive(Debug, PartialEq)]
struct Intrinsic {
    name: String,
    ret: Option<Type>,
    arguments: Vec<(Type, bool)>,
    instruction: String,
}

// These structures are similar to those in json_parser.rs in intrinsics-test
#[derive(Deserialize, Debug)]
struct JsonIntrinsic {
    name: String,
    arguments: Vec<String>,
    return_type: ReturnType,
    #[serde(default)]
    instructions: Option<Vec<Vec<String>>>,
}

#[derive(Deserialize, Debug)]
struct ReturnType {
    value: String,
}

fn parse_intrinsics(intrinsics: Vec<JsonIntrinsic>) -> HashMap<String, Intrinsic> {
    let mut ret = HashMap::new();
    for intr in intrinsics.into_iter() {
        let f = parse_intrinsic(intr);
        ret.insert(f.name.clone(), f);
    }
    ret
}

fn parse_intrinsic(mut intr: JsonIntrinsic) -> Intrinsic {
    let name = intr.name;
    // Remove '[' and ']' so that intrinsics of the form `svwhilerw[_s16]` becomes `svwhilerw_s16`.
    let name = name.replace('[', "").replace(']', "");
    let ret = if intr.return_type.value == "void" {
        None
    } else {
        Some(parse_ty(&intr.return_type.value))
    };

    // This ignores multiple instructions and different optional sequences for now to mimic
    // the old HTML scraping behaviour
    let instruction = intr
        .instructions
        .map_or(String::new(), |mut i| i.swap_remove(0).swap_remove(0));

    let arguments = intr
        .arguments
        .iter()
        .map(|s| {
            let ty = if let Some(i) = s.find('*') {
                &s[..i + 1]
            } else {
                s.rsplit_once(' ').unwrap().0.trim_start_matches("const ")
            };
            let ty = parse_ty(ty);
            let konst = s.contains("const") && !matches!(ty, Type::ConstPtr(_))
                || s.starts_with("enum")
                || s.rsplit_once(" ").unwrap().1.starts_with("imm");
            (ty, konst)
        })
        .collect::<Vec<_>>();

    Intrinsic {
        name,
        ret,
        instruction,
        arguments,
    }
}

fn parse_ty(s: &str) -> Type {
    if let Some(ty) = s.strip_suffix("*") {
        let ty = ty.trim();
        if let Some(ty) = ty.strip_prefix("const") {
            // SVE intrinsics are west-const (`const int8_t *`)
            Type::ConstPtr(parse_ty_base(ty))
        } else if let Some(ty) = ty.strip_suffix("const") {
            // Neon intrinsics are east-const (`int8_t const *`)
            Type::ConstPtr(parse_ty_base(ty))
        } else {
            Type::MutPtr(parse_ty_base(ty))
        }
    } else {
        *parse_ty_base(s)
    }
}

fn parse_ty_base(s: &str) -> &'static Type {
    let s = s.trim();
    match s {
        "bool" => &BOOL,
        "void" => &VOID,
        "float16_t" => &F16,
        "float16x4_t" => &F16X4,
        "float16x4x2_t" => &F16X4X2,
        "float16x4x3_t" => &F16X4X3,
        "float16x4x4_t" => &F16X4X4,
        "float16x8_t" => &F16X8,
        "float16x8x2_t" => &F16X8X2,
        "float16x8x3_t" => &F16X8X3,
        "float16x8x4_t" => &F16X8X4,
        "float32_t" => &F32,
        "float32x2_t" => &F32X2,
        "float32x2x2_t" => &F32X2X2,
        "float32x2x3_t" => &F32X2X3,
        "float32x2x4_t" => &F32X2X4,
        "float32x4_t" => &F32X4,
        "float32x4x2_t" => &F32X4X2,
        "float32x4x3_t" => &F32X4X3,
        "float32x4x4_t" => &F32X4X4,
        "float64_t" => &F64,
        "float64x1_t" => &F64X1,
        "float64x1x2_t" => &F64X1X2,
        "float64x1x3_t" => &F64X1X3,
        "float64x1x4_t" => &F64X1X4,
        "float64x2_t" => &F64X2,
        "float64x2x2_t" => &F64X2X2,
        "float64x2x3_t" => &F64X2X3,
        "float64x2x4_t" => &F64X2X4,
        "int16_t" => &I16,
        "int16x2_t" => &I16X2,
        "int16x4_t" => &I16X4,
        "int16x4x2_t" => &I16X4X2,
        "int16x4x3_t" => &I16X4X3,
        "int16x4x4_t" => &I16X4X4,
        "int16x8_t" => &I16X8,
        "int16x8x2_t" => &I16X8X2,
        "int16x8x3_t" => &I16X8X3,
        "int16x8x4_t" => &I16X8X4,
        "int32_t" | "int" => &I32,
        "int32x2_t" => &I32X2,
        "int32x2x2_t" => &I32X2X2,
        "int32x2x3_t" => &I32X2X3,
        "int32x2x4_t" => &I32X2X4,
        "int32x4_t" => &I32X4,
        "int32x4x2_t" => &I32X4X2,
        "int32x4x3_t" => &I32X4X3,
        "int32x4x4_t" => &I32X4X4,
        "int64_t" => &I64,
        "int64x1_t" => &I64X1,
        "int64x1x2_t" => &I64X1X2,
        "int64x1x3_t" => &I64X1X3,
        "int64x1x4_t" => &I64X1X4,
        "int64x2_t" => &I64X2,
        "int64x2x2_t" => &I64X2X2,
        "int64x2x3_t" => &I64X2X3,
        "int64x2x4_t" => &I64X2X4,
        "int8_t" => &I8,
        "int8x16_t" => &I8X16,
        "int8x16x2_t" => &I8X16X2,
        "int8x16x3_t" => &I8X16X3,
        "int8x16x4_t" => &I8X16X4,
        "int8x4_t" => &I8X4,
        "int8x8_t" => &I8X8,
        "int8x8x2_t" => &I8X8X2,
        "int8x8x3_t" => &I8X8X3,
        "int8x8x4_t" => &I8X8X4,
        "poly128_t" => &P128,
        "poly16_t" => &P16,
        "poly16x4_t" => &POLY16X4,
        "poly16x4x2_t" => &P16X4X2,
        "poly16x4x3_t" => &P16X4X3,
        "poly16x4x4_t" => &P16X4X4,
        "poly16x8_t" => &POLY16X8,
        "poly16x8x2_t" => &P16X8X2,
        "poly16x8x3_t" => &P16X8X3,
        "poly16x8x4_t" => &P16X8X4,
        "poly64_t" => &P64,
        "poly64x1_t" => &POLY64X1,
        "poly64x1x2_t" => &P64X1X2,
        "poly64x1x3_t" => &P64X1X3,
        "poly64x1x4_t" => &P64X1X4,
        "poly64x2_t" => &POLY64X2,
        "poly64x2x2_t" => &P64X2X2,
        "poly64x2x3_t" => &P64X2X3,
        "poly64x2x4_t" => &P64X2X4,
        "poly8_t" => &P8,
        "poly8x16_t" => &POLY8X16,
        "poly8x16x2_t" => &POLY8X16X2,
        "poly8x16x3_t" => &POLY8X16X3,
        "poly8x16x4_t" => &POLY8X16X4,
        "poly8x8_t" => &POLY8X8,
        "poly8x8x2_t" => &POLY8X8X2,
        "poly8x8x3_t" => &POLY8X8X3,
        "poly8x8x4_t" => &POLY8X8X4,
        "uint16_t" => &U16,
        "uint16x4_t" => &U16X4,
        "uint16x4x2_t" => &U16X4X2,
        "uint16x4x3_t" => &U16X4X3,
        "uint16x4x4_t" => &U16X4X4,
        "uint16x8_t" => &U16X8,
        "uint16x8x2_t" => &U16X8X2,
        "uint16x8x3_t" => &U16X8X3,
        "uint16x8x4_t" => &U16X8X4,
        "uint32_t" => &U32,
        "uint32x2_t" => &U32X2,
        "uint32x2x2_t" => &U32X2X2,
        "uint32x2x3_t" => &U32X2X3,
        "uint32x2x4_t" => &U32X2X4,
        "uint32x4_t" => &U32X4,
        "uint32x4x2_t" => &U32X4X2,
        "uint32x4x3_t" => &U32X4X3,
        "uint32x4x4_t" => &U32X4X4,
        "uint64_t" => &U64,
        "uint64x1_t" => &U64X1,
        "uint64x1x2_t" => &U64X1X2,
        "uint64x1x3_t" => &U64X1X3,
        "uint64x1x4_t" => &U64X1X4,
        "uint64x2_t" => &U64X2,
        "uint64x2x2_t" => &U64X2X2,
        "uint64x2x3_t" => &U64X2X3,
        "uint64x2x4_t" => &U64X2X4,
        "uint8_t" => &U8,
        "uint8x16_t" => &U8X16,
        "uint8x16x2_t" => &U8X16X2,
        "uint8x16x3_t" => &U8X16X3,
        "uint8x16x4_t" => &U8X16X4,
        "uint8x8_t" => &U8X8,
        "uint8x8x2_t" => &U8X8X2,
        "uint8x8x3_t" => &U8X8X3,
        "uint8x8x4_t" => &U8X8X4,
        "svbool_t" => &SVBOOL,
        "svboolx2_t" => &SVBOOLX2,
        "svboolx3_t" => &SVBOOLX3,
        "svboolx4_t" => &SVBOOLX4,
        "svcount_t" => &SVCOUNT,
        "svfloat16_t" => &SVF16,
        "svfloat16x2_t" => &SVF16X2,
        "svfloat16x3_t" => &SVF16X3,
        "svfloat16x4_t" => &SVF16X4,
        "svfloat32_t" => &SVF32,
        "svfloat32x2_t" => &SVF32X2,
        "svfloat32x3_t" => &SVF32X3,
        "svfloat32x4_t" => &SVF32X4,
        "svfloat64_t" => &SVF64,
        "svfloat64x2_t" => &SVF64X2,
        "svfloat64x3_t" => &SVF64X3,
        "svfloat64x4_t" => &SVF64X4,
        "svint8_t" => &SVI8,
        "svint8x2_t" => &SVI8X2,
        "svint8x3_t" => &SVI8X3,
        "svint8x4_t" => &SVI8X4,
        "svint16_t" => &SVI16,
        "svint16x2_t" => &SVI16X2,
        "svint16x3_t" => &SVI16X3,
        "svint16x4_t" => &SVI16X4,
        "svint32_t" => &SVI32,
        "svint32x2_t" => &SVI32X2,
        "svint32x3_t" => &SVI32X3,
        "svint32x4_t" => &SVI32X4,
        "svint64_t" => &SVI64,
        "svint64x2_t" => &SVI64X2,
        "svint64x3_t" => &SVI64X3,
        "svint64x4_t" => &SVI64X4,
        "svuint8_t" => &SVU8,
        "svuint8x2_t" => &SVU8X2,
        "svuint8x3_t" => &SVU8X3,
        "svuint8x4_t" => &SVU8X4,
        "svuint16_t" => &SVU16,
        "svuint16x2_t" => &SVU16X2,
        "svuint16x3_t" => &SVU16X3,
        "svuint16x4_t" => &SVU16X4,
        "svuint32_t" => &SVU32,
        "svuint32x2_t" => &SVU32X2,
        "svuint32x3_t" => &SVU32X3,
        "svuint32x4_t" => &SVU32X4,
        "svuint64_t" => &SVU64,
        "svuint64x2_t" => &SVU64X2,
        "svuint64x3_t" => &SVU64X3,
        "svuint64x4_t" => &SVU64X4,
        "enum svprfop" => &SVPRFOP,
        "enum svpattern" => &SVPATTERN,

        _ => panic!("failed to parse json type {s:?}"),
    }
}

// FIXME(arm-maintainers): Some tests require new rustc intrinsics in order to generate
// the appropriate instruction, though they do have the correct behaviour - these will be fixed
// but are disabled for now.
static SKIP_ASSERT_INSTR_TESTS: &'static [&'static str] = &["svpfalse_b"];

// FIXME(arm-maintainers): With the advent of the `intrinsic-test` tool, new tests of this kind
// are no longer being added and just adding to this list indefinitely isn't the best solution for
// dealing with that.
static SKIP_RUNTIME_TESTS: &'static [&'static str] = &[
    "vaddq_s64",
    "vaddq_u64",
    "vrsqrte_f32",
    "vtbl1_s8",
    "vtbl1_u8",
    "vtbl1_p8",
    "vtbl2_s8",
    "vtbl2_u8",
    "vtbl2_p8",
    "vtbl3_s8",
    "vtbl3_u8",
    "vtbl3_p8",
    "vtbl4_s8",
    "vtbl4_u8",
    "vtbl4_p8",
    "vtbx1_s8",
    "vtbx1_u8",
    "vtbx1_p8",
    "vtbx2_s8",
    "vtbx2_u8",
    "vtbx2_p8",
    "vtbx3_s8",
    "vtbx3_u8",
    "vtbx3_p8",
    "vtbx4_s8",
    "vtbx4_u8",
    "vtbx4_p8",
    "udf",
    "_clz_u8",
    "_clz_u16",
    "_clz_u32",
    "_rbit_u32",
    "_rev_u16",
    "_rev_u32",
    "__breakpoint",
    "vpminq_f32",
    "vpminq_f64",
    "vpmaxq_f32",
    "vpmaxq_f64",
    "vcombine_s8",
    "vcombine_s16",
    "vcombine_s32",
    "vcombine_s64",
    "vcombine_u8",
    "vcombine_u16",
    "vcombine_u32",
    "vcombine_u64",
    "vcombine_p64",
    "vcombine_f32",
    "vcombine_p8",
    "vcombine_p16",
    "vcombine_f64",
    "vtbl1_s8",
    "vtbl1_u8",
    "vtbl1_p8",
    "vtbl2_s8",
    "vtbl2_u8",
    "vtbl2_p8",
    "vtbl3_s8",
    "vtbl3_u8",
    "vtbl3_p8",
    "vtbl4_s8",
    "vtbl4_u8",
    "vtbl4_p8",
    "vtbx1_s8",
    "vtbx1_u8",
    "vtbx1_p8",
    "vtbx2_s8",
    "vtbx2_u8",
    "vtbx2_p8",
    "vtbx3_s8",
    "vtbx3_u8",
    "vtbx3_p8",
    "vtbx4_s8",
    "vtbx4_u8",
    "vtbx4_p8",
    "vqtbl1_s8",
    "vqtbl1q_s8",
    "vqtbl1_u8",
    "vqtbl1q_u8",
    "vqtbl1_p8",
    "vqtbl1q_p8",
    "vqtbx1_s8",
    "vqtbx1q_s8",
    "vqtbx1_u8",
    "vqtbx1q_u8",
    "vqtbx1_p8",
    "vqtbx1q_p8",
    "vqtbl2_s8",
    "vqtbl2q_s8",
    "vqtbl2_u8",
    "vqtbl2q_u8",
    "vqtbl2_p8",
    "vqtbl2q_p8",
    "vqtbx2_s8",
    "vqtbx2q_s8",
    "vqtbx2_u8",
    "vqtbx2q_u8",
    "vqtbx2_p8",
    "vqtbx2q_p8",
    "vqtbl3_s8",
    "vqtbl3q_s8",
    "vqtbl3_u8",
    "vqtbl3q_u8",
    "vqtbl3_p8",
    "vqtbl3q_p8",
    "vqtbx3_s8",
    "vqtbx3q_s8",
    "vqtbx3_u8",
    "vqtbx3q_u8",
    "vqtbx3_p8",
    "vqtbx3q_p8",
    "vqtbl4_s8",
    "vqtbl4q_s8",
    "vqtbl4_u8",
    "vqtbl4q_u8",
    "vqtbl4_p8",
    "vqtbl4q_p8",
    "vqtbx4_s8",
    "vqtbx4q_s8",
    "vqtbx4_u8",
    "vqtbx4q_u8",
    "vqtbx4_p8",
    "vqtbx4q_p8",
    "brk",
    "_rev_u64",
    "_clz_u64",
    "_rbit_u64",
    "_cls_u32",
    "_cls_u64",
    "_prefetch",
    "vsli_n_s8",
    "vsliq_n_s8",
    "vsli_n_s16",
    "vsliq_n_s16",
    "vsli_n_s32",
    "vsliq_n_s32",
    "vsli_n_s64",
    "vsliq_n_s64",
    "vsli_n_u8",
    "vsliq_n_u8",
    "vsli_n_u16",
    "vsliq_n_u16",
    "vsli_n_u32",
    "vsliq_n_u32",
    "vsli_n_u64",
    "vsliq_n_u64",
    "vsli_n_p8",
    "vsliq_n_p8",
    "vsli_n_p16",
    "vsliq_n_p16",
    "vsli_n_p64",
    "vsliq_n_p64",
    "vsri_n_s8",
    "vsriq_n_s8",
    "vsri_n_s16",
    "vsriq_n_s16",
    "vsri_n_s32",
    "vsriq_n_s32",
    "vsri_n_s64",
    "vsriq_n_s64",
    "vsri_n_u8",
    "vsriq_n_u8",
    "vsri_n_u16",
    "vsriq_n_u16",
    "vsri_n_u32",
    "vsriq_n_u32",
    "vsri_n_u64",
    "vsriq_n_u64",
    "vsri_n_p8",
    "vsriq_n_p8",
    "vsri_n_p16",
    "vsriq_n_p16",
    "vsri_n_p64",
    "vsriq_n_p64",
    "__smulbb",
    "__smultb",
    "__smulbt",
    "__smultt",
    "__smulwb",
    "__smulwt",
    "__qadd",
    "__qsub",
    "__qdbl",
    "__smlabb",
    "__smlabt",
    "__smlatb",
    "__smlatt",
    "__smlawb",
    "__smlawt",
    "__qadd8",
    "__qsub8",
    "__qsub16",
    "__qadd16",
    "__qasx",
    "__qsax",
    "__sadd16",
    "__sadd8",
    "__smlad",
    "__smlsd",
    "__sasx",
    "__sel",
    "__shadd8",
    "__shadd16",
    "__shsub8",
    "__usub8",
    "__ssub8",
    "__shsub16",
    "__smuad",
    "__smuadx",
    "__smusd",
    "__smusdx",
    "__usad8",
    "__usada8",
    "__ldrex",
    "__strex",
    "__ldrexb",
    "__strexb",
    "__ldrexh",
    "__strexh",
    "__clrex",
    "__dbg",
    "__crc32cd",
    "__crc32d",
    "__jcvt",
    "vabal_high_s8",
    "vabal_high_s16",
    "vabal_high_s32",
    "vabal_high_u8",
    "vabal_high_u16",
    "vabal_high_u32",
    "vabd_f64",
    "vabdq_f64",
    "vabdd_f64",
    "vabds_f32",
    "vabdh_f16",
    "vabdl_high_s16",
    "vabdl_high_s32",
    "vabdl_high_s8",
    "vabdl_high_u8",
    "vabdl_high_u16",
    "vabdl_high_u32",
    "vabs_f64",
    "vabsq_f64",
    "vabs_s64",
    "vabsq_s64",
    "vabsd_s64",
    "vaddlv_s16",
    "vaddlvq_s16",
    "vaddlvq_s32",
    "vaddlv_s32",
    "vaddlv_s8",
    "vaddlvq_s8",
    "vaddlv_u16",
    "vaddlvq_u16",
    "vaddlvq_u32",
    "vaddlv_u32",
    "vaddlv_u8",
    "vaddlvq_u8",
    "vaddv_f32",
    "vaddvq_f32",
    "vaddvq_f64",
    "vaddv_s32",
    "vaddv_s8",
    "vaddvq_s8",
    "vaddv_s16",
    "vaddvq_s16",
    "vaddvq_s32",
    "vaddv_u32",
    "vaddv_u8",
    "vaddvq_u8",
    "vaddv_u16",
    "vaddvq_u16",
    "vaddvq_u32",
    "vaddvq_s64",
    "vaddvq_u64",
    "vamax_f16",
    "vamaxq_f16",
    "vamax_f32",
    "vamaxq_f32",
    "vamaxq_f64",
    "vamin_f16",
    "vaminq_f16",
    "vamin_f32",
    "vaminq_f32",
    "vaminq_f64",
    "vbcaxq_s8",
    "vbcaxq_s16",
    "vbcaxq_s32",
    "vbcaxq_s64",
    "vbcaxq_u8",
    "vbcaxq_u16",
    "vbcaxq_u32",
    "vbcaxq_u64",
    "vcadd_rot270_f16",
    "vcaddq_rot270_f16",
    "vcadd_rot270_f32",
    "vcaddq_rot270_f32",
    "vcaddq_rot270_f64",
    "vcadd_rot90_f16",
    "vcaddq_rot90_f16",
    "vcadd_rot90_f32",
    "vcaddq_rot90_f32",
    "vcaddq_rot90_f64",
    "vcage_f64",
    "vcageq_f64",
    "vcaged_f64",
    "vcages_f32",
    "vcageh_f16",
    "vcagt_f64",
    "vcagtq_f64",
    "vcagtd_f64",
    "vcagts_f32",
    "vcagth_f16",
    "vcale_f64",
    "vcaleq_f64",
    "vcaled_f64",
    "vcales_f32",
    "vcaleh_f16",
    "vcalt_f64",
    "vcaltq_f64",
    "vcaltd_f64",
    "vcalts_f32",
    "vcalth_f16",
    "vceq_f64",
    "vceqq_f64",
    "vceq_s64",
    "vceqq_s64",
    "vceq_u64",
    "vceqq_u64",
    "vceq_p64",
    "vceqq_p64",
    "vceqd_f64",
    "vceqs_f32",
    "vceqd_s64",
    "vceqd_u64",
    "vceqh_f16",
    "vceqz_f16",
    "vceqzq_f16",
    "vceqz_f32",
    "vceqzq_f32",
    "vceqz_f64",
    "vceqzq_f64",
    "vceqz_s8",
    "vceqzq_s8",
    "vceqz_s16",
    "vceqzq_s16",
    "vceqz_s32",
    "vceqzq_s32",
    "vceqz_s64",
    "vceqzq_s64",
    "vceqz_p8",
    "vceqzq_p8",
    "vceqz_p64",
    "vceqzq_p64",
    "vceqz_u8",
    "vceqzq_u8",
    "vceqz_u16",
    "vceqzq_u16",
    "vceqz_u32",
    "vceqzq_u32",
    "vceqz_u64",
    "vceqzq_u64",
    "vceqzd_s64",
    "vceqzd_u64",
    "vceqzh_f16",
    "vceqzs_f32",
    "vceqzd_f64",
    "vcge_f64",
    "vcgeq_f64",
    "vcge_s64",
    "vcgeq_s64",
    "vcge_u64",
    "vcgeq_u64",
    "vcged_f64",
    "vcges_f32",
    "vcged_s64",
    "vcged_u64",
    "vcgeh_f16",
    "vcgez_f32",
    "vcgezq_f32",
    "vcgez_f64",
    "vcgezq_f64",
    "vcgez_s8",
    "vcgezq_s8",
    "vcgez_s16",
    "vcgezq_s16",
    "vcgez_s32",
    "vcgezq_s32",
    "vcgez_s64",
    "vcgezq_s64",
    "vcgezd_f64",
    "vcgezs_f32",
    "vcgezd_s64",
    "vcgezh_f16",
    "vcgt_f64",
    "vcgtq_f64",
    "vcgt_s64",
    "vcgtq_s64",
    "vcgt_u64",
    "vcgtq_u64",
    "vcgtd_f64",
    "vcgts_f32",
    "vcgtd_s64",
    "vcgtd_u64",
    "vcgth_f16",
    "vcgtz_f32",
    "vcgtzq_f32",
    "vcgtz_f64",
    "vcgtzq_f64",
    "vcgtz_s8",
    "vcgtzq_s8",
    "vcgtz_s16",
    "vcgtzq_s16",
    "vcgtz_s32",
    "vcgtzq_s32",
    "vcgtz_s64",
    "vcgtzq_s64",
    "vcgtzd_f64",
    "vcgtzs_f32",
    "vcgtzd_s64",
    "vcgtzh_f16",
    "vcle_f64",
    "vcleq_f64",
    "vcle_s64",
    "vcleq_s64",
    "vcle_u64",
    "vcleq_u64",
    "vcled_f64",
    "vcles_f32",
    "vcled_u64",
    "vcled_s64",
    "vcleh_f16",
    "vclez_f32",
    "vclezq_f32",
    "vclez_f64",
    "vclezq_f64",
    "vclez_s8",
    "vclezq_s8",
    "vclez_s16",
    "vclezq_s16",
    "vclez_s32",
    "vclezq_s32",
    "vclez_s64",
    "vclezq_s64",
    "vclezd_f64",
    "vclezs_f32",
    "vclezd_s64",
    "vclezh_f16",
    "vclt_f64",
    "vcltq_f64",
    "vclt_s64",
    "vcltq_s64",
    "vclt_u64",
    "vcltq_u64",
    "vcltd_u64",
    "vcltd_s64",
    "vclth_f16",
    "vclts_f32",
    "vcltd_f64",
    "vcltz_f32",
    "vcltzq_f32",
    "vcltz_f64",
    "vcltzq_f64",
    "vcltz_s8",
    "vcltzq_s8",
    "vcltz_s16",
    "vcltzq_s16",
    "vcltz_s32",
    "vcltzq_s32",
    "vcltz_s64",
    "vcltzq_s64",
    "vcltzd_f64",
    "vcltzs_f32",
    "vcltzd_s64",
    "vcltzh_f16",
    "vcmla_f16",
    "vcmlaq_f16",
    "vcmla_f32",
    "vcmlaq_f32",
    "vcmlaq_f64",
    "vcmla_lane_f16",
    "vcmlaq_lane_f16",
    "vcmla_lane_f32",
    "vcmlaq_lane_f32",
    "vcmla_laneq_f16",
    "vcmlaq_laneq_f16",
    "vcmla_laneq_f32",
    "vcmlaq_laneq_f32",
    "vcmla_rot180_f16",
    "vcmlaq_rot180_f16",
    "vcmla_rot180_f32",
    "vcmlaq_rot180_f32",
    "vcmlaq_rot180_f64",
    "vcmla_rot180_lane_f16",
    "vcmlaq_rot180_lane_f16",
    "vcmla_rot180_lane_f32",
    "vcmlaq_rot180_lane_f32",
    "vcmla_rot180_laneq_f16",
    "vcmlaq_rot180_laneq_f16",
    "vcmla_rot180_laneq_f32",
    "vcmlaq_rot180_laneq_f32",
    "vcmla_rot270_f16",
    "vcmlaq_rot270_f16",
    "vcmla_rot270_f32",
    "vcmlaq_rot270_f32",
    "vcmlaq_rot270_f64",
    "vcmla_rot270_lane_f16",
    "vcmlaq_rot270_lane_f16",
    "vcmla_rot270_lane_f32",
    "vcmlaq_rot270_lane_f32",
    "vcmla_rot270_laneq_f16",
    "vcmlaq_rot270_laneq_f16",
    "vcmla_rot270_laneq_f32",
    "vcmlaq_rot270_laneq_f32",
    "vcmla_rot90_f16",
    "vcmlaq_rot90_f16",
    "vcmla_rot90_f32",
    "vcmlaq_rot90_f32",
    "vcmlaq_rot90_f64",
    "vcmla_rot90_lane_f16",
    "vcmlaq_rot90_lane_f16",
    "vcmla_rot90_lane_f32",
    "vcmlaq_rot90_lane_f32",
    "vcmla_rot90_laneq_f16",
    "vcmlaq_rot90_laneq_f16",
    "vcmla_rot90_laneq_f32",
    "vcmlaq_rot90_laneq_f32",
    "vcopy_lane_f32",
    "vcopy_lane_s8",
    "vcopy_lane_s16",
    "vcopy_lane_s32",
    "vcopy_lane_u8",
    "vcopy_lane_u16",
    "vcopy_lane_u32",
    "vcopy_lane_p8",
    "vcopy_lane_p16",
    "vcopy_laneq_f32",
    "vcopy_laneq_s8",
    "vcopy_laneq_s16",
    "vcopy_laneq_s32",
    "vcopy_laneq_u8",
    "vcopy_laneq_u16",
    "vcopy_laneq_u32",
    "vcopy_laneq_p8",
    "vcopy_laneq_p16",
    "vcopyq_lane_f32",
    "vcopyq_lane_f64",
    "vcopyq_lane_s64",
    "vcopyq_lane_u64",
    "vcopyq_lane_p64",
    "vcopyq_lane_s8",
    "vcopyq_lane_s16",
    "vcopyq_lane_s32",
    "vcopyq_lane_u8",
    "vcopyq_lane_u16",
    "vcopyq_lane_u32",
    "vcopyq_lane_p8",
    "vcopyq_lane_p16",
    "vcopyq_laneq_f32",
    "vcopyq_laneq_f64",
    "vcopyq_laneq_s8",
    "vcopyq_laneq_s16",
    "vcopyq_laneq_s32",
    "vcopyq_laneq_s64",
    "vcopyq_laneq_u8",
    "vcopyq_laneq_u16",
    "vcopyq_laneq_u32",
    "vcopyq_laneq_u64",
    "vcopyq_laneq_p8",
    "vcopyq_laneq_p16",
    "vcopyq_laneq_p64",
    "vcreate_f64",
    "vcvt_f32_f64",
    "vcvt_f64_f32",
    "vcvt_f64_s64",
    "vcvtq_f64_s64",
    "vcvt_f64_u64",
    "vcvtq_f64_u64",
    "vcvt_high_f16_f32",
    "vcvt_high_f32_f16",
    "vcvt_high_f32_f64",
    "vcvt_high_f64_f32",
    "vcvt_n_f64_s64",
    "vcvtq_n_f64_s64",
    "vcvt_n_f64_u64",
    "vcvtq_n_f64_u64",
    "vcvt_n_s64_f64",
    "vcvtq_n_s64_f64",
    "vcvt_n_u64_f64",
    "vcvtq_n_u64_f64",
    "vcvt_s64_f64",
    "vcvtq_s64_f64",
    "vcvt_u64_f64",
    "vcvtq_u64_f64",
    "vcvta_s16_f16",
    "vcvtaq_s16_f16",
    "vcvta_s32_f32",
    "vcvtaq_s32_f32",
    "vcvta_s64_f64",
    "vcvtaq_s64_f64",
    "vcvta_u16_f16",
    "vcvtaq_u16_f16",
    "vcvta_u32_f32",
    "vcvtaq_u32_f32",
    "vcvta_u64_f64",
    "vcvtaq_u64_f64",
    "vcvtah_s16_f16",
    "vcvtah_s32_f16",
    "vcvtah_s64_f16",
    "vcvtah_u16_f16",
    "vcvtah_u32_f16",
    "vcvtah_u64_f16",
    "vcvtas_s32_f32",
    "vcvtad_s64_f64",
    "vcvtas_u32_f32",
    "vcvtad_u64_f64",
    "vcvtd_f64_s64",
    "vcvts_f32_s32",
    "vcvth_f16_s16",
    "vcvth_f16_s32",
    "vcvth_f16_s64",
    "vcvth_f16_u16",
    "vcvth_f16_u32",
    "vcvth_f16_u64",
    "vcvth_n_f16_s16",
    "vcvth_n_f16_s32",
    "vcvth_n_f16_s64",
    "vcvth_n_f16_u16",
    "vcvth_n_f16_u32",
    "vcvth_n_f16_u64",
    "vcvth_n_s16_f16",
    "vcvth_n_s32_f16",
    "vcvth_n_s64_f16",
    "vcvth_n_u16_f16",
    "vcvth_n_u32_f16",
    "vcvth_n_u64_f16",
    "vcvth_s16_f16",
    "vcvth_s32_f16",
    "vcvth_s64_f16",
    "vcvth_u16_f16",
    "vcvth_u32_f16",
    "vcvth_u64_f16",
    "vcvtm_s16_f16",
    "vcvtmq_s16_f16",
    "vcvtm_s32_f32",
    "vcvtmq_s32_f32",
    "vcvtm_s64_f64",
    "vcvtmq_s64_f64",
    "vcvtm_u16_f16",
    "vcvtmq_u16_f16",
    "vcvtm_u32_f32",
    "vcvtmq_u32_f32",
    "vcvtm_u64_f64",
    "vcvtmq_u64_f64",
    "vcvtmh_s16_f16",
    "vcvtmh_s32_f16",
    "vcvtmh_s64_f16",
    "vcvtmh_u16_f16",
    "vcvtmh_u32_f16",
    "vcvtmh_u64_f16",
    "vcvtms_s32_f32",
    "vcvtmd_s64_f64",
    "vcvtms_u32_f32",
    "vcvtmd_u64_f64",
    "vcvtn_s16_f16",
    "vcvtnq_s16_f16",
    "vcvtn_s32_f32",
    "vcvtnq_s32_f32",
    "vcvtn_s64_f64",
    "vcvtnq_s64_f64",
    "vcvtn_u16_f16",
    "vcvtnq_u16_f16",
    "vcvtn_u32_f32",
    "vcvtnq_u32_f32",
    "vcvtn_u64_f64",
    "vcvtnq_u64_f64",
    "vcvtnh_s16_f16",
    "vcvtnh_s32_f16",
    "vcvtnh_s64_f16",
    "vcvtnh_u16_f16",
    "vcvtnh_u32_f16",
    "vcvtnh_u64_f16",
    "vcvtns_s32_f32",
    "vcvtnd_s64_f64",
    "vcvtns_u32_f32",
    "vcvtnd_u64_f64",
    "vcvtp_s16_f16",
    "vcvtpq_s16_f16",
    "vcvtp_s32_f32",
    "vcvtpq_s32_f32",
    "vcvtp_s64_f64",
    "vcvtpq_s64_f64",
    "vcvtp_u16_f16",
    "vcvtpq_u16_f16",
    "vcvtp_u32_f32",
    "vcvtpq_u32_f32",
    "vcvtp_u64_f64",
    "vcvtpq_u64_f64",
    "vcvtph_s16_f16",
    "vcvtph_s32_f16",
    "vcvtph_s64_f16",
    "vcvtph_u16_f16",
    "vcvtph_u32_f16",
    "vcvtph_u64_f16",
    "vcvtps_s32_f32",
    "vcvtpd_s64_f64",
    "vcvtps_u32_f32",
    "vcvtpd_u64_f64",
    "vcvts_f32_u32",
    "vcvtd_f64_u64",
    "vcvts_n_f32_s32",
    "vcvtd_n_f64_s64",
    "vcvts_n_f32_u32",
    "vcvtd_n_f64_u64",
    "vcvts_n_s32_f32",
    "vcvtd_n_s64_f64",
    "vcvts_n_u32_f32",
    "vcvtd_n_u64_f64",
    "vcvts_s32_f32",
    "vcvtd_s64_f64",
    "vcvts_u32_f32",
    "vcvtd_u64_f64",
    "vcvtx_f32_f64",
    "vcvtx_high_f32_f64",
    "vcvtxd_f32_f64",
    "vdiv_f16",
    "vdivq_f16",
    "vdiv_f32",
    "vdivq_f32",
    "vdiv_f64",
    "vdivq_f64",
    "vdivh_f16",
    "vdup_lane_f64",
    "vdup_lane_p64",
    "vdup_laneq_f64",
    "vdup_laneq_p64",
    "vdupb_lane_s8",
    "vduph_laneq_s16",
    "vdupb_lane_u8",
    "vduph_laneq_u16",
    "vdupb_lane_p8",
    "vduph_laneq_p16",
    "vdupb_laneq_s8",
    "vdupb_laneq_u8",
    "vdupb_laneq_p8",
    "vdupd_lane_f64",
    "vdupd_lane_s64",
    "vdupd_lane_u64",
    "vduph_lane_f16",
    "vduph_laneq_f16",
    "vdupq_lane_f64",
    "vdupq_lane_p64",
    "vdupq_laneq_f64",
    "vdupq_laneq_p64",
    "vdups_lane_f32",
    "vdupd_laneq_f64",
    "vdups_lane_s32",
    "vdupd_laneq_s64",
    "vdups_lane_u32",
    "vdupd_laneq_u64",
    "vdups_laneq_f32",
    "vduph_lane_s16",
    "vdups_laneq_s32",
    "vduph_lane_u16",
    "vdups_laneq_u32",
    "vduph_lane_p16",
    "veor3q_s8",
    "veor3q_s16",
    "veor3q_s32",
    "veor3q_s64",
    "veor3q_u8",
    "veor3q_u16",
    "veor3q_u32",
    "veor3q_u64",
    "vextq_f64",
    "vextq_p64",
    "vfma_f64",
    "vfma_lane_f16",
    "vfma_laneq_f16",
    "vfmaq_lane_f16",
    "vfmaq_laneq_f16",
    "vfma_lane_f32",
    "vfma_laneq_f32",
    "vfmaq_lane_f32",
    "vfmaq_laneq_f32",
    "vfmaq_laneq_f64",
    "vfma_lane_f64",
    "vfma_laneq_f64",
    "vfma_n_f16",
    "vfmaq_n_f16",
    "vfma_n_f64",
    "vfmad_lane_f64",
    "vfmah_f16",
    "vfmah_lane_f16",
    "vfmah_laneq_f16",
    "vfmaq_f64",
    "vfmaq_lane_f64",
    "vfmaq_n_f64",
    "vfmas_lane_f32",
    "vfmas_laneq_f32",
    "vfmad_laneq_f64",
    "vfmlal_high_f16",
    "vfmlalq_high_f16",
    "vfmlal_lane_high_f16",
    "vfmlal_laneq_high_f16",
    "vfmlalq_lane_high_f16",
    "vfmlalq_laneq_high_f16",
    "vfmlal_lane_low_f16",
    "vfmlal_laneq_low_f16",
    "vfmlalq_lane_low_f16",
    "vfmlalq_laneq_low_f16",
    "vfmlal_low_f16",
    "vfmlalq_low_f16",
    "vfmlsl_high_f16",
    "vfmlslq_high_f16",
    "vfmlsl_lane_high_f16",
    "vfmlsl_laneq_high_f16",
    "vfmlslq_lane_high_f16",
    "vfmlslq_laneq_high_f16",
    "vfmlsl_lane_low_f16",
    "vfmlsl_laneq_low_f16",
    "vfmlslq_lane_low_f16",
    "vfmlslq_laneq_low_f16",
    "vfmlsl_low_f16",
    "vfmlslq_low_f16",
    "vfms_f64",
    "vfms_lane_f16",
    "vfms_laneq_f16",
    "vfmsq_lane_f16",
    "vfmsq_laneq_f16",
    "vfms_lane_f32",
    "vfms_laneq_f32",
    "vfmsq_lane_f32",
    "vfmsq_laneq_f32",
    "vfmsq_laneq_f64",
    "vfms_lane_f64",
    "vfms_laneq_f64",
    "vfms_n_f16",
    "vfmsq_n_f16",
    "vfms_n_f64",
    "vfmsh_f16",
    "vfmsh_lane_f16",
    "vfmsh_laneq_f16",
    "vfmsq_f64",
    "vfmsq_lane_f64",
    "vfmsq_n_f64",
    "vfmss_lane_f32",
    "vfmss_laneq_f32",
    "vfmsd_lane_f64",
    "vfmsd_laneq_f64",
    "vld1_f16",
    "vld1q_f16",
    "vld1_f64_x2",
    "vld1_f64_x3",
    "vld1_f64_x4",
    "vld1q_f64_x2",
    "vld1q_f64_x3",
    "vld1q_f64_x4",
    "vld2_dup_f64",
    "vld2q_dup_f64",
    "vld2q_dup_s64",
    "vld2_f64",
    "vld2_lane_f64",
    "vld2_lane_s64",
    "vld2_lane_p64",
    "vld2_lane_u64",
    "vld2q_dup_p64",
    "vld2q_dup_p64",
    "vld2q_dup_u64",
    "vld2q_dup_u64",
    "vld2q_f64",
    "vld2q_s64",
    "vld2q_lane_f64",
    "vld2q_lane_s8",
    "vld2q_lane_s64",
    "vld2q_lane_p64",
    "vld2q_lane_u8",
    "vld2q_lane_u64",
    "vld2q_lane_p8",
    "vld2q_p64",
    "vld2q_p64",
    "vld2q_u64",
    "vld3_dup_f64",
    "vld3q_dup_f64",
    "vld3q_dup_s64",
    "vld3_f64",
    "vld3_lane_f64",
    "vld3_lane_p64",
    "vld3_lane_s64",
    "vld3_lane_u64",
    "vld3q_dup_p64",
    "vld3q_dup_p64",
    "vld3q_dup_u64",
    "vld3q_dup_u64",
    "vld3q_f64",
    "vld3q_s64",
    "vld3q_lane_f64",
    "vld3q_lane_p64",
    "vld3q_lane_s8",
    "vld3q_lane_s64",
    "vld3q_lane_u8",
    "vld3q_lane_u64",
    "vld3q_lane_p8",
    "vld3q_p64",
    "vld3q_p64",
    "vld3q_u64",
    "vld4_dup_f64",
    "vld4q_dup_f64",
    "vld4q_dup_s64",
    "vld4_f64",
    "vld4_lane_f64",
    "vld4_lane_s64",
    "vld4_lane_p64",
    "vld4_lane_u64",
    "vld4q_dup_p64",
    "vld4q_dup_p64",
    "vld4q_dup_u64",
    "vld4q_dup_u64",
    "vld4q_f64",
    "vld4q_s64",
    "vld4q_lane_f64",
    "vld4q_lane_s8",
    "vld4q_lane_s64",
    "vld4q_lane_p64",
    "vld4q_lane_u8",
    "vld4q_lane_u64",
    "vld4q_lane_p8",
    "vld4q_p64",
    "vld4q_p64",
    "vld4q_u64",
    "vldap1_lane_s64",
    "vldap1q_lane_s64",
    "vldap1q_lane_f64",
    "vldap1_lane_u64",
    "vldap1q_lane_u64",
    "vldap1_lane_p64",
    "vldap1q_lane_p64",
    "vluti2_lane_f16",
    "vluti2q_lane_f16",
    "vluti2_lane_u8",
    "vluti2q_lane_u8",
    "vluti2_lane_u16",
    "vluti2q_lane_u16",
    "vluti2_lane_p8",
    "vluti2q_lane_p8",
    "vluti2_lane_p16",
    "vluti2q_lane_p16",
    "vluti2_lane_s8",
    "vluti2q_lane_s8",
    "vluti2_lane_s16",
    "vluti2q_lane_s16",
    "vluti2_laneq_f16",
    "vluti2q_laneq_f16",
    "vluti2_laneq_u8",
    "vluti2q_laneq_u8",
    "vluti2_laneq_u16",
    "vluti2q_laneq_u16",
    "vluti2_laneq_p8",
    "vluti2q_laneq_p8",
    "vluti2_laneq_p16",
    "vluti2q_laneq_p16",
    "vluti2_laneq_s8",
    "vluti2q_laneq_s8",
    "vluti2_laneq_s16",
    "vluti2q_laneq_s16",
    "vluti4q_lane_f16_x2",
    "vluti4q_lane_u16_x2",
    "vluti4q_lane_p16_x2",
    "vluti4q_lane_s16_x2",
    "vluti4q_lane_s8",
    "vluti4q_lane_u8",
    "vluti4q_lane_p8",
    "vluti4q_laneq_f16_x2",
    "vluti4q_laneq_u16_x2",
    "vluti4q_laneq_p16_x2",
    "vluti4q_laneq_s16_x2",
    "vluti4q_laneq_s8",
    "vluti4q_laneq_u8",
    "vluti4q_laneq_p8",
    "vmax_f64",
    "vmaxq_f64",
    "vmaxh_f16",
    "vmaxnm_f64",
    "vmaxnmq_f64",
    "vmaxnmh_f16",
    "vmaxnmv_f16",
    "vmaxnmvq_f16",
    "vmaxnmv_f32",
    "vmaxnmvq_f64",
    "vmaxnmvq_f32",
    "vmaxv_f16",
    "vmaxvq_f16",
    "vmaxv_f32",
    "vmaxvq_f32",
    "vmaxvq_f64",
    "vmaxv_s8",
    "vmaxvq_s8",
    "vmaxv_s16",
    "vmaxvq_s16",
    "vmaxv_s32",
    "vmaxvq_s32",
    "vmaxv_u8",
    "vmaxvq_u8",
    "vmaxv_u16",
    "vmaxvq_u16",
    "vmaxv_u32",
    "vmaxvq_u32",
    "vmin_f64",
    "vminq_f64",
    "vminh_f16",
    "vminnm_f64",
    "vminnmq_f64",
    "vminnmh_f16",
    "vminnmv_f16",
    "vminnmvq_f16",
    "vminnmv_f32",
    "vminnmvq_f64",
    "vminnmvq_f32",
    "vminv_f16",
    "vminvq_f16",
    "vminv_f32",
    "vminvq_f32",
    "vminvq_f64",
    "vminv_s8",
    "vminvq_s8",
    "vminv_s16",
    "vminvq_s16",
    "vminv_s32",
    "vminvq_s32",
    "vminv_u8",
    "vminvq_u8",
    "vminv_u16",
    "vminvq_u16",
    "vminv_u32",
    "vminvq_u32",
    "vmla_f64",
    "vmlaq_f64",
    "vmlal_high_lane_s16",
    "vmlal_high_laneq_s16",
    "vmlal_high_lane_s32",
    "vmlal_high_laneq_s32",
    "vmlal_high_lane_u16",
    "vmlal_high_laneq_u16",
    "vmlal_high_lane_u32",
    "vmlal_high_laneq_u32",
    "vmlal_high_n_s16",
    "vmlal_high_n_s32",
    "vmlal_high_n_u16",
    "vmlal_high_n_u32",
    "vmlal_high_s8",
    "vmlal_high_s16",
    "vmlal_high_s32",
    "vmlal_high_u8",
    "vmlal_high_u16",
    "vmlal_high_u32",
    "vmls_f64",
    "vmlsq_f64",
    "vmlsl_high_lane_s16",
    "vmlsl_high_laneq_s16",
    "vmlsl_high_lane_s32",
    "vmlsl_high_laneq_s32",
    "vmlsl_high_lane_u16",
    "vmlsl_high_laneq_u16",
    "vmlsl_high_lane_u32",
    "vmlsl_high_laneq_u32",
    "vmlsl_high_n_s16",
    "vmlsl_high_n_s32",
    "vmlsl_high_n_u16",
    "vmlsl_high_n_u32",
    "vmlsl_high_s8",
    "vmlsl_high_s16",
    "vmlsl_high_s32",
    "vmlsl_high_u8",
    "vmlsl_high_u16",
    "vmlsl_high_u32",
    "vmovl_high_s8",
    "vmovl_high_s16",
    "vmovl_high_s32",
    "vmovl_high_u8",
    "vmovl_high_u16",
    "vmovl_high_u32",
    "vmovn_high_s16",
    "vmovn_high_s32",
    "vmovn_high_s64",
    "vmovn_high_u16",
    "vmovn_high_u32",
    "vmovn_high_u64",
    "vmul_f64",
    "vmulq_f64",
    "vmul_lane_f64",
    "vmul_laneq_f16",
    "vmulq_laneq_f16",
    "vmul_laneq_f64",
    "vmul_n_f64",
    "vmulq_n_f64",
    "vmuld_lane_f64",
    "vmulh_f16",
    "vmulh_lane_f16",
    "vmulh_laneq_f16",
    "vmull_high_lane_s16",
    "vmull_high_laneq_s16",
    "vmull_high_lane_s32",
    "vmull_high_laneq_s32",
    "vmull_high_lane_u16",
    "vmull_high_laneq_u16",
    "vmull_high_lane_u32",
    "vmull_high_laneq_u32",
    "vmull_high_n_s16",
    "vmull_high_n_s32",
    "vmull_high_n_u16",
    "vmull_high_n_u32",
    "vmull_high_p64",
    "vmull_high_p8",
    "vmull_high_s8",
    "vmull_high_s16",
    "vmull_high_s32",
    "vmull_high_u8",
    "vmull_high_u16",
    "vmull_high_u32",
    "vmull_p64",
    "vmulq_lane_f64",
    "vmulq_laneq_f64",
    "vmuls_lane_f32",
    "vmuls_laneq_f32",
    "vmuld_laneq_f64",
    "vmulx_f16",
    "vmulxq_f16",
    "vmulx_f32",
    "vmulxq_f32",
    "vmulx_f64",
    "vmulxq_f64",
    "vmulx_lane_f16",
    "vmulx_laneq_f16",
    "vmulxq_lane_f16",
    "vmulxq_laneq_f16",
    "vmulx_lane_f32",
    "vmulx_laneq_f32",
    "vmulxq_lane_f32",
    "vmulxq_laneq_f32",
    "vmulxq_laneq_f64",
    "vmulx_lane_f64",
    "vmulx_laneq_f64",
    "vmulx_n_f16",
    "vmulxq_n_f16",
    "vmulxd_f64",
    "vmulxs_f32",
    "vmulxd_lane_f64",
    "vmulxd_laneq_f64",
    "vmulxs_lane_f32",
    "vmulxs_laneq_f32",
    "vmulxh_f16",
    "vmulxh_lane_f16",
    "vmulxh_laneq_f16",
    "vmulxq_lane_f64",
    "vneg_f64",
    "vnegq_f64",
    "vneg_s64",
    "vnegq_s64",
    "vnegd_s64",
    "vnegh_f16",
    "vpaddd_f64",
    "vpadds_f32",
    "vpaddd_s64",
    "vpaddd_u64",
    "vpaddq_f16",
    "vpaddq_f32",
    "vpaddq_f64",
    "vpaddq_s8",
    "vpaddq_s16",
    "vpaddq_s32",
    "vpaddq_s64",
    "vpaddq_u8",
    "vpaddq_u16",
    "vpaddq_u32",
    "vpaddq_u64",
    "vpmax_f16",
    "vpmaxq_f16",
    "vpmaxnm_f16",
    "vpmaxnmq_f16",
    "vpmaxnm_f32",
    "vpmaxnmq_f32",
    "vpmaxnmq_f64",
    "vpmaxnmqd_f64",
    "vpmaxnms_f32",
    "vpmaxq_s8",
    "vpmaxq_s16",
    "vpmaxq_s32",
    "vpmaxq_u8",
    "vpmaxq_u16",
    "vpmaxq_u32",
    "vpmaxqd_f64",
    "vpmaxs_f32",
    "vpmin_f16",
    "vpminq_f16",
    "vpminnm_f16",
    "vpminnmq_f16",
    "vpminnm_f32",
    "vpminnmq_f32",
    "vpminnmq_f64",
    "vpminnmqd_f64",
    "vpminnms_f32",
    "vpminq_s8",
    "vpminq_s16",
    "vpminq_s32",
    "vpminq_u8",
    "vpminq_u16",
    "vpminq_u32",
    "vpminqd_f64",
    "vpmins_f32",
    "vqabs_s64",
    "vqabsq_s64",
    "vqabsb_s8",
    "vqabsh_s16",
    "vqabss_s32",
    "vqabsd_s64",
    "vqaddb_s8",
    "vqaddh_s16",
    "vqaddb_u8",
    "vqaddh_u16",
    "vqadds_s32",
    "vqaddd_s64",
    "vqadds_u32",
    "vqaddd_u64",
    "vqdmlal_high_lane_s16",
    "vqdmlal_high_laneq_s16",
    "vqdmlal_high_lane_s32",
    "vqdmlal_high_laneq_s32",
    "vqdmlal_high_n_s16",
    "vqdmlal_high_s16",
    "vqdmlal_high_n_s32",
    "vqdmlal_high_s32",
    "vqdmlal_laneq_s16",
    "vqdmlal_laneq_s32",
    "vqdmlalh_lane_s16",
    "vqdmlalh_laneq_s16",
    "vqdmlals_lane_s32",
    "vqdmlals_laneq_s32",
    "vqdmlalh_s16",
    "vqdmlals_s32",
    "vqdmlsl_high_lane_s16",
    "vqdmlsl_high_laneq_s16",
    "vqdmlsl_high_lane_s32",
    "vqdmlsl_high_laneq_s32",
    "vqdmlsl_high_n_s16",
    "vqdmlsl_high_s16",
    "vqdmlsl_high_n_s32",
    "vqdmlsl_high_s32",
    "vqdmlsl_laneq_s16",
    "vqdmlsl_laneq_s32",
    "vqdmlslh_lane_s16",
    "vqdmlslh_laneq_s16",
    "vqdmlsls_lane_s32",
    "vqdmlsls_laneq_s32",
    "vqdmlslh_s16",
    "vqdmlsls_s32",
    "vqdmulh_lane_s16",
    "vqdmulhq_lane_s16",
    "vqdmulh_lane_s32",
    "vqdmulhq_lane_s32",
    "vqdmulhh_lane_s16",
    "vqdmulhh_laneq_s16",
    "vqdmulhh_s16",
    "vqdmulhs_s32",
    "vqdmulhs_lane_s32",
    "vqdmulhs_laneq_s32",
    "vqdmull_high_lane_s16",
    "vqdmull_high_laneq_s32",
    "vqdmull_high_lane_s32",
    "vqdmull_high_laneq_s16",
    "vqdmull_high_n_s16",
    "vqdmull_high_n_s32",
    "vqdmull_high_s16",
    "vqdmull_high_s32",
    "vqdmull_laneq_s16",
    "vqdmull_laneq_s32",
    "vqdmullh_lane_s16",
    "vqdmulls_laneq_s32",
    "vqdmullh_laneq_s16",
    "vqdmullh_s16",
    "vqdmulls_lane_s32",
    "vqdmulls_s32",
    "vqmovn_high_s16",
    "vqmovn_high_s32",
    "vqmovn_high_s64",
    "vqmovn_high_u16",
    "vqmovn_high_u32",
    "vqmovn_high_u64",
    "vqmovnd_s64",
    "vqmovnd_u64",
    "vqmovnh_s16",
    "vqmovns_s32",
    "vqmovnh_u16",
    "vqmovns_u32",
    "vqmovun_high_s16",
    "vqmovun_high_s32",
    "vqmovun_high_s64",
    "vqmovunh_s16",
    "vqmovuns_s32",
    "vqmovund_s64",
    "vqneg_s64",
    "vqnegq_s64",
    "vqnegb_s8",
    "vqnegh_s16",
    "vqnegs_s32",
    "vqnegd_s64",
    "vqrdmlah_lane_s16",
    "vqrdmlah_lane_s32",
    "vqrdmlah_laneq_s16",
    "vqrdmlah_laneq_s32",
    "vqrdmlahq_lane_s16",
    "vqrdmlahq_lane_s32",
    "vqrdmlahq_laneq_s16",
    "vqrdmlahq_laneq_s32",
    "vqrdmlah_s16",
    "vqrdmlahq_s16",
    "vqrdmlah_s32",
    "vqrdmlahq_s32",
    "vqrdmlahh_lane_s16",
    "vqrdmlahh_laneq_s16",
    "vqrdmlahs_lane_s32",
    "vqrdmlahs_laneq_s32",
    "vqrdmlahh_s16",
    "vqrdmlahs_s32",
    "vqrdmlsh_lane_s16",
    "vqrdmlsh_lane_s32",
    "vqrdmlsh_laneq_s16",
    "vqrdmlsh_laneq_s32",
    "vqrdmlshq_lane_s16",
    "vqrdmlshq_lane_s32",
    "vqrdmlshq_laneq_s16",
    "vqrdmlshq_laneq_s32",
    "vqrdmlsh_s16",
    "vqrdmlshq_s16",
    "vqrdmlsh_s32",
    "vqrdmlshq_s32",
    "vqrdmlshh_lane_s16",
    "vqrdmlshh_laneq_s16",
    "vqrdmlshs_lane_s32",
    "vqrdmlshs_laneq_s32",
    "vqrdmlshh_s16",
    "vqrdmlshs_s32",
    "vqrdmulhh_lane_s16",
    "vqrdmulhh_laneq_s16",
    "vqrdmulhs_lane_s32",
    "vqrdmulhs_laneq_s32",
    "vqrdmulhh_s16",
    "vqrdmulhs_s32",
    "vqrshlb_s8",
    "vqrshlh_s16",
    "vqrshlb_u8",
    "vqrshlh_u16",
    "vqrshld_s64",
    "vqrshls_s32",
    "vqrshls_u32",
    "vqrshld_u64",
    "vqrshrn_high_n_s16",
    "vqrshrn_high_n_s32",
    "vqrshrn_high_n_s64",
    "vqrshrn_high_n_u16",
    "vqrshrn_high_n_u32",
    "vqrshrn_high_n_u64",
    "vqrshrnd_n_u64",
    "vqrshrnh_n_u16",
    "vqrshrns_n_u32",
    "vqrshrnh_n_s16",
    "vqrshrns_n_s32",
    "vqrshrnd_n_s64",
    "vqrshrun_high_n_s16",
    "vqrshrun_high_n_s32",
    "vqrshrun_high_n_s64",
    "vqrshrund_n_s64",
    "vqrshrunh_n_s16",
    "vqrshruns_n_s32",
    "vqshlb_n_s8",
    "vqshld_n_s64",
    "vqshlh_n_s16",
    "vqshls_n_s32",
    "vqshlb_n_u8",
    "vqshld_n_u64",
    "vqshlh_n_u16",
    "vqshls_n_u32",
    "vqshlb_s8",
    "vqshlh_s16",
    "vqshls_s32",
    "vqshlb_u8",
    "vqshlh_u16",
    "vqshls_u32",
    "vqshld_s64",
    "vqshld_u64",
    "vqshlub_n_s8",
    "vqshlud_n_s64",
    "vqshluh_n_s16",
    "vqshlus_n_s32",
    "vqshrn_high_n_s16",
    "vqshrn_high_n_s32",
    "vqshrn_high_n_s64",
    "vqshrn_high_n_u16",
    "vqshrn_high_n_u32",
    "vqshrn_high_n_u64",
    "vqshrnd_n_s64",
    "vqshrnd_n_u64",
    "vqshrnh_n_s16",
    "vqshrns_n_s32",
    "vqshrnh_n_u16",
    "vqshrns_n_u32",
    "vqshrun_high_n_s16",
    "vqshrun_high_n_s32",
    "vqshrun_high_n_s64",
    "vqshrund_n_s64",
    "vqshrunh_n_s16",
    "vqshruns_n_s32",
    "vqsubb_s8",
    "vqsubh_s16",
    "vqsubb_u8",
    "vqsubh_u16",
    "vqsubs_s32",
    "vqsubd_s64",
    "vqsubs_u32",
    "vqsubd_u64",
    "vrax1q_u64",
    "vrbit_s8",
    "vrbitq_s8",
    "vrbit_u8",
    "vrbit_u8",
    "vrbitq_u8",
    "vrbitq_u8",
    "vrbit_p8",
    "vrbit_p8",
    "vrbitq_p8",
    "vrbitq_p8",
    "vrecpe_f64",
    "vrecpeq_f64",
    "vrecped_f64",
    "vrecpes_f32",
    "vrecpeh_f16",
    "vrecps_f64",
    "vrecpsq_f64",
    "vrecpsd_f64",
    "vrecpss_f32",
    "vrecpsh_f16",
    "vrecpxd_f64",
    "vrecpxs_f32",
    "vrecpxh_f16",
    "vreinterpret_f64_f16",
    "vreinterpret_f64_f16",
    "vreinterpretq_f64_f16",
    "vreinterpretq_f64_f16",
    "vreinterpret_f16_f64",
    "vreinterpret_f16_f64",
    "vreinterpretq_f16_f64",
    "vreinterpretq_f16_f64",
    "vreinterpretq_f64_p128",
    "vreinterpretq_f64_p128",
    "vreinterpret_f64_f32",
    "vreinterpret_f64_f32",
    "vreinterpret_p64_f32",
    "vreinterpret_p64_f32",
    "vreinterpretq_f64_f32",
    "vreinterpretq_f64_f32",
    "vreinterpretq_p64_f32",
    "vreinterpretq_p64_f32",
    "vreinterpret_f32_f64",
    "vreinterpret_f32_f64",
    "vreinterpret_s8_f64",
    "vreinterpret_s8_f64",
    "vreinterpret_s16_f64",
    "vreinterpret_s16_f64",
    "vreinterpret_s32_f64",
    "vreinterpret_s32_f64",
    "vreinterpret_s64_f64",
    "vreinterpret_u8_f64",
    "vreinterpret_u8_f64",
    "vreinterpret_u16_f64",
    "vreinterpret_u16_f64",
    "vreinterpret_u32_f64",
    "vreinterpret_u32_f64",
    "vreinterpret_u64_f64",
    "vreinterpret_p8_f64",
    "vreinterpret_p8_f64",
    "vreinterpret_p16_f64",
    "vreinterpret_p16_f64",
    "vreinterpret_p64_f64",
    "vreinterpretq_p128_f64",
    "vreinterpretq_p128_f64",
    "vreinterpretq_f32_f64",
    "vreinterpretq_f32_f64",
    "vreinterpretq_s8_f64",
    "vreinterpretq_s8_f64",
    "vreinterpretq_s16_f64",
    "vreinterpretq_s16_f64",
    "vreinterpretq_s32_f64",
    "vreinterpretq_s32_f64",
    "vreinterpretq_s64_f64",
    "vreinterpretq_s64_f64",
    "vreinterpretq_u8_f64",
    "vreinterpretq_u8_f64",
    "vreinterpretq_u16_f64",
    "vreinterpretq_u16_f64",
    "vreinterpretq_u32_f64",
    "vreinterpretq_u32_f64",
    "vreinterpretq_u64_f64",
    "vreinterpretq_u64_f64",
    "vreinterpretq_p8_f64",
    "vreinterpretq_p8_f64",
    "vreinterpretq_p16_f64",
    "vreinterpretq_p16_f64",
    "vreinterpretq_p64_f64",
    "vreinterpretq_p64_f64",
    "vreinterpret_f64_s8",
    "vreinterpret_f64_s8",
    "vreinterpretq_f64_s8",
    "vreinterpretq_f64_s8",
    "vreinterpret_f64_s16",
    "vreinterpret_f64_s16",
    "vreinterpretq_f64_s16",
    "vreinterpretq_f64_s16",
    "vreinterpret_f64_s32",
    "vreinterpret_f64_s32",
    "vreinterpretq_f64_s32",
    "vreinterpretq_f64_s32",
    "vreinterpret_f64_s64",
    "vreinterpret_p64_s64",
    "vreinterpretq_f64_s64",
    "vreinterpretq_f64_s64",
    "vreinterpretq_p64_s64",
    "vreinterpretq_p64_s64",
    "vreinterpret_f64_u8",
    "vreinterpret_f64_u8",
    "vreinterpretq_f64_u8",
    "vreinterpretq_f64_u8",
    "vreinterpret_f64_u16",
    "vreinterpret_f64_u16",
    "vreinterpretq_f64_u16",
    "vreinterpretq_f64_u16",
    "vreinterpret_f64_u32",
    "vreinterpret_f64_u32",
    "vreinterpretq_f64_u32",
    "vreinterpretq_f64_u32",
    "vreinterpret_f64_u64",
    "vreinterpret_p64_u64",
    "vreinterpretq_f64_u64",
    "vreinterpretq_f64_u64",
    "vreinterpretq_p64_u64",
    "vreinterpretq_p64_u64",
    "vreinterpret_f64_p8",
    "vreinterpret_f64_p8",
    "vreinterpretq_f64_p8",
    "vreinterpretq_f64_p8",
    "vreinterpret_f64_p16",
    "vreinterpret_f64_p16",
    "vreinterpretq_f64_p16",
    "vreinterpretq_f64_p16",
    "vreinterpret_f32_p64",
    "vreinterpret_f32_p64",
    "vreinterpret_f64_p64",
    "vreinterpret_s64_p64",
    "vreinterpret_u64_p64",
    "vreinterpretq_f32_p64",
    "vreinterpretq_f32_p64",
    "vreinterpretq_f64_p64",
    "vreinterpretq_f64_p64",
    "vreinterpretq_s64_p64",
    "vreinterpretq_s64_p64",
    "vreinterpretq_u64_p64",
    "vreinterpretq_u64_p64",
    "vrnd32x_f32",
    "vrnd32xq_f32",
    "vrnd32xq_f64",
    "vrnd32x_f64",
    "vrnd32z_f32",
    "vrnd32zq_f32",
    "vrnd32zq_f64",
    "vrnd32z_f64",
    "vrnd64x_f32",
    "vrnd64xq_f32",
    "vrnd64xq_f64",
    "vrnd64x_f64",
    "vrnd64z_f32",
    "vrnd64zq_f32",
    "vrnd64zq_f64",
    "vrnd64z_f64",
    "vrnd_f16",
    "vrndq_f16",
    "vrnd_f32",
    "vrndq_f32",
    "vrnd_f64",
    "vrndq_f64",
    "vrnda_f16",
    "vrndaq_f16",
    "vrnda_f32",
    "vrndaq_f32",
    "vrnda_f64",
    "vrndaq_f64",
    "vrndah_f16",
    "vrndh_f16",
    "vrndi_f16",
    "vrndiq_f16",
    "vrndi_f32",
    "vrndiq_f32",
    "vrndi_f64",
    "vrndiq_f64",
    "vrndih_f16",
    "vrndm_f16",
    "vrndmq_f16",
    "vrndm_f32",
    "vrndmq_f32",
    "vrndm_f64",
    "vrndmq_f64",
    "vrndmh_f16",
    "vrndn_f64",
    "vrndnq_f64",
    "vrndnh_f16",
    "vrndns_f32",
    "vrndp_f16",
    "vrndpq_f16",
    "vrndp_f32",
    "vrndpq_f32",
    "vrndp_f64",
    "vrndpq_f64",
    "vrndph_f16",
    "vrndx_f16",
    "vrndxq_f16",
    "vrndx_f32",
    "vrndxq_f32",
    "vrndx_f64",
    "vrndxq_f64",
    "vrndxh_f16",
    "vrshld_s64",
    "vrshld_u64",
    "vrshrd_n_s64",
    "vrshrd_n_u64",
    "vrshrn_high_n_s16",
    "vrshrn_high_n_s32",
    "vrshrn_high_n_s64",
    "vrshrn_high_n_u16",
    "vrshrn_high_n_u32",
    "vrshrn_high_n_u64",
    "vrsqrte_f64",
    "vrsqrteq_f64",
    "vrsqrted_f64",
    "vrsqrtes_f32",
    "vrsqrteh_f16",
    "vrsqrts_f64",
    "vrsqrtsq_f64",
    "vrsqrtsd_f64",
    "vrsqrtss_f32",
    "vrsqrtsh_f16",
    "vrsrad_n_s64",
    "vrsrad_n_u64",
    "vrsubhn_high_s16",
    "vrsubhn_high_s32",
    "vrsubhn_high_s64",
    "vrsubhn_high_u16",
    "vrsubhn_high_u32",
    "vrsubhn_high_u64",
    "vrsubhn_high_s16",
    "vrsubhn_high_s32",
    "vrsubhn_high_s64",
    "vrsubhn_high_u16",
    "vrsubhn_high_u32",
    "vrsubhn_high_u64",
    "vscale_f16",
    "vscaleq_f16",
    "vscale_f32",
    "vscaleq_f32",
    "vscaleq_f64",
    "vset_lane_f64",
    "vsetq_lane_f64",
    "vsha512h2q_u64",
    "vsha512hq_u64",
    "vsha512su0q_u64",
    "vsha512su1q_u64",
    "vshld_s64",
    "vshld_u64",
    "vshll_high_n_s8",
    "vshll_high_n_s16",
    "vshll_high_n_s32",
    "vshll_high_n_u8",
    "vshll_high_n_u16",
    "vshll_high_n_u32",
    "vshrn_high_n_s16",
    "vshrn_high_n_s32",
    "vshrn_high_n_s64",
    "vshrn_high_n_u16",
    "vshrn_high_n_u32",
    "vshrn_high_n_u64",
    "vslid_n_s64",
    "vslid_n_u64",
    "vsm3partw1q_u32",
    "vsm3partw2q_u32",
    "vsm3ss1q_u32",
    "vsm3tt1aq_u32",
    "vsm3tt1bq_u32",
    "vsm3tt2aq_u32",
    "vsm3tt2bq_u32",
    "vsm4ekeyq_u32",
    "vsm4eq_u32",
    "vsqadd_u8",
    "vsqaddq_u8",
    "vsqadd_u16",
    "vsqaddq_u16",
    "vsqadd_u32",
    "vsqaddq_u32",
    "vsqadd_u64",
    "vsqaddq_u64",
    "vsqaddb_u8",
    "vsqaddh_u16",
    "vsqaddd_u64",
    "vsqadds_u32",
    "vsqrt_f16",
    "vsqrtq_f16",
    "vsqrt_f32",
    "vsqrtq_f32",
    "vsqrt_f64",
    "vsqrtq_f64",
    "vsqrth_f16",
    "vsrid_n_s64",
    "vsrid_n_u64",
    "vst1_f16",
    "vst1q_f16",
    "vst1_f64_x2",
    "vst1q_f64_x2",
    "vst1_f64_x3",
    "vst1q_f64_x3",
    "vst1_f64_x4",
    "vst1q_f64_x4",
    "vst1_lane_f64",
    "vst1q_lane_f64",
    "vst2_f64",
    "vst2_lane_f64",
    "vst2_lane_s64",
    "vst2_lane_p64",
    "vst2_lane_u64",
    "vst2q_f64",
    "vst2q_s64",
    "vst2q_lane_f64",
    "vst2q_lane_s8",
    "vst2q_lane_s64",
    "vst2q_lane_p64",
    "vst2q_lane_u8",
    "vst2q_lane_u64",
    "vst2q_lane_p8",
    "vst2q_p64",
    "vst2q_u64",
    "vst3_f64",
    "vst3_lane_f64",
    "vst3_lane_s64",
    "vst3_lane_p64",
    "vst3_lane_u64",
    "vst3q_f64",
    "vst3q_s64",
    "vst3q_lane_f64",
    "vst3q_lane_s8",
    "vst3q_lane_s64",
    "vst3q_lane_p64",
    "vst3q_lane_u8",
    "vst3q_lane_u64",
    "vst3q_lane_p8",
    "vst3q_p64",
    "vst3q_u64",
    "vst4_f64",
    "vst4_lane_f64",
    "vst4_lane_s64",
    "vst4_lane_p64",
    "vst4_lane_u64",
    "vst4q_f64",
    "vst4q_s64",
    "vst4q_lane_f64",
    "vst4q_lane_s8",
    "vst4q_lane_s64",
    "vst4q_lane_p64",
    "vst4q_lane_u8",
    "vst4q_lane_u64",
    "vst4q_lane_p8",
    "vst4q_p64",
    "vst4q_u64",
    "vstl1_lane_f64",
    "vstl1q_lane_f64",
    "vstl1_lane_u64",
    "vstl1q_lane_u64",
    "vstl1_lane_p64",
    "vstl1q_lane_p64",
    "vstl1_lane_s64",
    "vstl1q_lane_s64",
    "vsub_f64",
    "vsubq_f64",
    "vsubd_s64",
    "vsubd_u64",
    "vsubh_f16",
    "vsubl_high_s8",
    "vsubl_high_s16",
    "vsubl_high_s32",
    "vsubl_high_u8",
    "vsubl_high_u16",
    "vsubl_high_u32",
    "vsubw_high_s8",
    "vsubw_high_s16",
    "vsubw_high_s32",
    "vsubw_high_u8",
    "vsubw_high_u16",
    "vsubw_high_u32",
    "vtrn1_f16",
    "vtrn1q_f16",
    "vtrn1_f32",
    "vtrn1q_f64",
    "vtrn1_s32",
    "vtrn1q_s64",
    "vtrn1_u32",
    "vtrn1q_u64",
    "vtrn1q_p64",
    "vtrn1q_f32",
    "vtrn1_s8",
    "vtrn1q_s8",
    "vtrn1_s16",
    "vtrn1q_s16",
    "vtrn1q_s32",
    "vtrn1_u8",
    "vtrn1q_u8",
    "vtrn1_u16",
    "vtrn1q_u16",
    "vtrn1q_u32",
    "vtrn1_p8",
    "vtrn1q_p8",
    "vtrn1_p16",
    "vtrn1q_p16",
    "vtrn2_f16",
    "vtrn2q_f16",
    "vtrn2_f32",
    "vtrn2q_f64",
    "vtrn2_s32",
    "vtrn2q_s64",
    "vtrn2_u32",
    "vtrn2q_u64",
    "vtrn2q_p64",
    "vtrn2q_f32",
    "vtrn2_s8",
    "vtrn2q_s8",
    "vtrn2_s16",
    "vtrn2q_s16",
    "vtrn2q_s32",
    "vtrn2_u8",
    "vtrn2q_u8",
    "vtrn2_u16",
    "vtrn2q_u16",
    "vtrn2q_u32",
    "vtrn2_p8",
    "vtrn2q_p8",
    "vtrn2_p16",
    "vtrn2q_p16",
    "vtst_s64",
    "vtstq_s64",
    "vtst_p64",
    "vtstq_p64",
    "vtst_u64",
    "vtstq_u64",
    "vtstd_s64",
    "vtstd_u64",
    "vuqadd_s8",
    "vuqaddq_s8",
    "vuqadd_s16",
    "vuqaddq_s16",
    "vuqadd_s32",
    "vuqaddq_s32",
    "vuqadd_s64",
    "vuqaddq_s64",
    "vuqaddb_s8",
    "vuqaddh_s16",
    "vuqaddd_s64",
    "vuqadds_s32",
    "vuzp1_f16",
    "vuzp1q_f16",
    "vuzp1_f32",
    "vuzp1q_f64",
    "vuzp1_s32",
    "vuzp1q_s64",
    "vuzp1_u32",
    "vuzp1q_u64",
    "vuzp1q_p64",
    "vuzp1q_f32",
    "vuzp1_s8",
    "vuzp1q_s8",
    "vuzp1_s16",
    "vuzp1q_s16",
    "vuzp1q_s32",
    "vuzp1_u8",
    "vuzp1q_u8",
    "vuzp1_u16",
    "vuzp1q_u16",
    "vuzp1q_u32",
    "vuzp1_p8",
    "vuzp1q_p8",
    "vuzp1_p16",
    "vuzp1q_p16",
    "vuzp2_f16",
    "vuzp2q_f16",
    "vuzp2_f32",
    "vuzp2q_f64",
    "vuzp2_s32",
    "vuzp2q_s64",
    "vuzp2_u32",
    "vuzp2q_u64",
    "vuzp2q_p64",
    "vuzp2q_f32",
    "vuzp2_s8",
    "vuzp2q_s8",
    "vuzp2_s16",
    "vuzp2q_s16",
    "vuzp2q_s32",
    "vuzp2_u8",
    "vuzp2q_u8",
    "vuzp2_u16",
    "vuzp2q_u16",
    "vuzp2q_u32",
    "vuzp2_p8",
    "vuzp2q_p8",
    "vuzp2_p16",
    "vuzp2q_p16",
    "vxarq_u64",
    "vzip1_f16",
    "vzip1q_f16",
    "vzip1_f32",
    "vzip1q_f32",
    "vzip1q_f64",
    "vzip1_s8",
    "vzip1q_s8",
    "vzip1_s16",
    "vzip1q_s16",
    "vzip1_s32",
    "vzip1q_s32",
    "vzip1q_s64",
    "vzip1_u8",
    "vzip1q_u8",
    "vzip1_u16",
    "vzip1q_u16",
    "vzip1_u32",
    "vzip1q_u32",
    "vzip1q_u64",
    "vzip1_p8",
    "vzip1q_p8",
    "vzip1_p16",
    "vzip1q_p16",
    "vzip1q_p64",
    "vzip2_f16",
    "vzip2q_f16",
    "vzip2_f32",
    "vzip2q_f32",
    "vzip2q_f64",
    "vzip2_s8",
    "vzip2q_s8",
    "vzip2_s16",
    "vzip2q_s16",
    "vzip2_s32",
    "vzip2q_s32",
    "vzip2q_s64",
    "vzip2_u8",
    "vzip2q_u8",
    "vzip2_u16",
    "vzip2q_u16",
    "vzip2_u32",
    "vzip2q_u32",
    "vzip2q_u64",
    "vzip2_p8",
    "vzip2q_p8",
    "vzip2_p16",
    "vzip2q_p16",
    "vzip2q_p64",
    "__crc32b",
    "__crc32cb",
    "__crc32cd",
    "__crc32ch",
    "__crc32cw",
    "__crc32d",
    "__crc32h",
    "__crc32w",
    "vabal_s8",
    "vabal_s16",
    "vabal_s32",
    "vabal_u8",
    "vabal_u16",
    "vabal_u32",
    "vabd_f16",
    "vabdq_f16",
    "vabd_f32",
    "vabdq_f32",
    "vabd_s8",
    "vabdq_s8",
    "vabd_s16",
    "vabdq_s16",
    "vabd_s32",
    "vabdq_s32",
    "vabd_u8",
    "vabdq_u8",
    "vabd_u16",
    "vabdq_u16",
    "vabd_u32",
    "vabdq_u32",
    "vabdl_s8",
    "vabdl_s16",
    "vabdl_s32",
    "vabdl_u8",
    "vabdl_u16",
    "vabdl_u32",
    "vabs_f16",
    "vabsq_f16",
    "vabs_f32",
    "vabsq_f32",
    "vabs_s8",
    "vabsq_s8",
    "vabs_s16",
    "vabsq_s16",
    "vabs_s32",
    "vabsq_s32",
    "vabsh_f16",
    "vadd_f16",
    "vaddq_f16",
    "vadd_p8",
    "vaddq_p8",
    "vadd_p16",
    "vaddq_p16",
    "vadd_p64",
    "vaddq_p64",
    "vaddh_f16",
    "vaddhn_high_s16",
    "vaddhn_high_s32",
    "vaddhn_high_s64",
    "vaddhn_high_u16",
    "vaddhn_high_u32",
    "vaddhn_high_u64",
    "vaddhn_s16",
    "vaddhn_s32",
    "vaddhn_s64",
    "vaddhn_u16",
    "vaddhn_u32",
    "vaddhn_u64",
    "vaddq_p128",
    "vaesdq_u8",
    "vaeseq_u8",
    "vaesimcq_u8",
    "vaesmcq_u8",
    "vbsl_f16",
    "vbslq_f16",
    "vcage_f16",
    "vcageq_f16",
    "vcage_f32",
    "vcageq_f32",
    "vcagt_f16",
    "vcagtq_f16",
    "vcagt_f32",
    "vcagtq_f32",
    "vcale_f16",
    "vcaleq_f16",
    "vcale_f32",
    "vcaleq_f32",
    "vcalt_f16",
    "vcaltq_f16",
    "vcalt_f32",
    "vcaltq_f32",
    "vceq_f16",
    "vceqq_f16",
    "vceq_p8",
    "vceqq_p8",
    "vcge_f16",
    "vcgeq_f16",
    "vcgez_f16",
    "vcgezq_f16",
    "vcgt_f16",
    "vcgtq_f16",
    "vcgtz_f16",
    "vcgtzq_f16",
    "vcle_f16",
    "vcleq_f16",
    "vclez_f16",
    "vclezq_f16",
    "vcls_s8",
    "vclsq_s8",
    "vcls_s16",
    "vclsq_s16",
    "vcls_s32",
    "vclsq_s32",
    "vcls_u8",
    "vclsq_u8",
    "vcls_u16",
    "vclsq_u16",
    "vcls_u32",
    "vclsq_u32",
    "vclt_f16",
    "vcltq_f16",
    "vcltz_f16",
    "vcltzq_f16",
    "vclz_s8",
    "vclzq_s8",
    "vclz_s16",
    "vclzq_s16",
    "vclz_s32",
    "vclzq_s32",
    "vclz_u16",
    "vclz_u16",
    "vclzq_u16",
    "vclzq_u16",
    "vclz_u32",
    "vclz_u32",
    "vclzq_u32",
    "vclzq_u32",
    "vclz_u8",
    "vclz_u8",
    "vclzq_u8",
    "vclzq_u8",
    "vcnt_s8",
    "vcntq_s8",
    "vcnt_u8",
    "vcnt_u8",
    "vcntq_u8",
    "vcntq_u8",
    "vcnt_p8",
    "vcnt_p8",
    "vcntq_p8",
    "vcntq_p8",
    "vcombine_f16",
    "vcreate_f16",
    "vcreate_f16",
    "vcreate_f32",
    "vcreate_f32",
    "vcreate_s8",
    "vcreate_s8",
    "vcreate_s16",
    "vcreate_s16",
    "vcreate_s32",
    "vcreate_s32",
    "vcreate_s64",
    "vcreate_u8",
    "vcreate_u8",
    "vcreate_u16",
    "vcreate_u16",
    "vcreate_u32",
    "vcreate_u32",
    "vcreate_u64",
    "vcreate_p8",
    "vcreate_p8",
    "vcreate_p16",
    "vcreate_p16",
    "vcreate_p64",
    "vcvt_f16_f32",
    "vcvt_f16_s16",
    "vcvtq_f16_s16",
    "vcvt_f16_u16",
    "vcvtq_f16_u16",
    "vcvt_f32_f16",
    "vcvt_f32_s32",
    "vcvtq_f32_s32",
    "vcvt_f32_u32",
    "vcvtq_f32_u32",
    "vcvt_n_f16_s16",
    "vcvtq_n_f16_s16",
    "vcvt_n_f16_u16",
    "vcvtq_n_f16_u16",
    "vcvt_n_f32_s32",
    "vcvtq_n_f32_s32",
    "vcvt_n_f32_s32",
    "vcvtq_n_f32_s32",
    "vcvt_n_f32_u32",
    "vcvtq_n_f32_u32",
    "vcvt_n_f32_u32",
    "vcvtq_n_f32_u32",
    "vcvt_n_s16_f16",
    "vcvtq_n_s16_f16",
    "vcvt_n_s32_f32",
    "vcvtq_n_s32_f32",
    "vcvt_n_s32_f32",
    "vcvtq_n_s32_f32",
    "vcvt_n_u16_f16",
    "vcvtq_n_u16_f16",
    "vcvt_n_u32_f32",
    "vcvtq_n_u32_f32",
    "vcvt_n_u32_f32",
    "vcvtq_n_u32_f32",
    "vcvt_s16_f16",
    "vcvtq_s16_f16",
    "vcvt_s32_f32",
    "vcvtq_s32_f32",
    "vcvt_u16_f16",
    "vcvtq_u16_f16",
    "vcvt_u32_f32",
    "vcvtq_u32_f32",
    "vdot_lane_s32",
    "vdot_lane_s32",
    "vdotq_lane_s32",
    "vdotq_lane_s32",
    "vdot_lane_u32",
    "vdot_lane_u32",
    "vdotq_lane_u32",
    "vdotq_lane_u32",
    "vdot_laneq_s32",
    "vdot_laneq_s32",
    "vdotq_laneq_s32",
    "vdotq_laneq_s32",
    "vdot_laneq_u32",
    "vdot_laneq_u32",
    "vdotq_laneq_u32",
    "vdotq_laneq_u32",
    "vdot_s32",
    "vdotq_s32",
    "vdot_u32",
    "vdotq_u32",
    "vdup_lane_f16",
    "vdupq_lane_f16",
    "vdup_lane_f32",
    "vdup_lane_s32",
    "vdup_lane_u32",
    "vdupq_lane_f32",
    "vdupq_lane_s32",
    "vdupq_lane_u32",
    "vdup_lane_p16",
    "vdup_lane_s16",
    "vdup_lane_u16",
    "vdupq_lane_p16",
    "vdupq_lane_s16",
    "vdupq_lane_u16",
    "vdup_lane_p8",
    "vdup_lane_s8",
    "vdup_lane_u8",
    "vdupq_lane_p8",
    "vdupq_lane_s8",
    "vdupq_lane_u8",
    "vdup_lane_s64",
    "vdup_lane_u64",
    "vdup_laneq_f16",
    "vdupq_laneq_f16",
    "vdup_laneq_f32",
    "vdup_laneq_s32",
    "vdup_laneq_u32",
    "vdupq_laneq_f32",
    "vdupq_laneq_s32",
    "vdupq_laneq_u32",
    "vdup_laneq_p16",
    "vdup_laneq_s16",
    "vdup_laneq_u16",
    "vdupq_laneq_p16",
    "vdupq_laneq_s16",
    "vdupq_laneq_u16",
    "vdup_laneq_p8",
    "vdup_laneq_s8",
    "vdup_laneq_u8",
    "vdupq_laneq_p8",
    "vdupq_laneq_s8",
    "vdupq_laneq_u8",
    "vdup_laneq_s64",
    "vdup_laneq_u64",
    "vdup_n_f16",
    "vdupq_n_f16",
    "vdupq_lane_s64",
    "vdupq_lane_u64",
    "vdupq_laneq_s64",
    "vdupq_laneq_u64",
    "vext_f16",
    "vext_f32",
    "vext_s32",
    "vext_u32",
    "vext_s8",
    "vextq_s16",
    "vext_u8",
    "vextq_u16",
    "vext_p8",
    "vextq_p16",
    "vextq_f16",
    "vextq_f32",
    "vext_s16",
    "vextq_s32",
    "vext_u16",
    "vextq_u32",
    "vext_p16",
    "vextq_s64",
    "vextq_u64",
    "vextq_s8",
    "vextq_u8",
    "vextq_p8",
    "vfma_f16",
    "vfmaq_f16",
    "vfma_f32",
    "vfmaq_f32",
    "vfma_n_f32",
    "vfmaq_n_f32",
    "vfms_f16",
    "vfmsq_f16",
    "vfms_f32",
    "vfmsq_f32",
    "vfms_n_f32",
    "vfmsq_n_f32",
    "vget_high_f16",
    "vget_low_f16",
    "vget_lane_f16",
    "vgetq_lane_f16",
    "vld1_dup_f16",
    "vld1q_dup_f16",
    "vld1_f16",
    "vld1_f16",
    "vld1q_f16",
    "vld1q_f16",
    "vld1_f16_x2",
    "vld1_f16_x3",
    "vld1_f16_x4",
    "vld1q_f16_x2",
    "vld1q_f16_x3",
    "vld1q_f16_x4",
    "vld1_f32_x2",
    "vld1_f32_x3",
    "vld1_f32_x4",
    "vld1q_f32_x2",
    "vld1q_f32_x3",
    "vld1q_f32_x4",
    "vld1_lane_f16",
    "vld1q_lane_f16",
    "vld1_p64_x2",
    "vld1_p64_x3",
    "vld1_p64_x4",
    "vld1q_p64_x2",
    "vld1q_p64_x3",
    "vld1q_p64_x4",
    "vld1_s8_x2",
    "vld1_s8_x3",
    "vld1_s8_x4",
    "vld1q_s8_x2",
    "vld1q_s8_x3",
    "vld1q_s8_x4",
    "vld1_s16_x2",
    "vld1_s16_x3",
    "vld1_s16_x4",
    "vld1q_s16_x2",
    "vld1q_s16_x3",
    "vld1q_s16_x4",
    "vld1_s32_x2",
    "vld1_s32_x3",
    "vld1_s32_x4",
    "vld1q_s32_x2",
    "vld1q_s32_x3",
    "vld1q_s32_x4",
    "vld1_s64_x2",
    "vld1_s64_x3",
    "vld1_s64_x4",
    "vld1q_s64_x2",
    "vld1q_s64_x3",
    "vld1q_s64_x4",
    "vld1_u8_x2",
    "vld1_u8_x3",
    "vld1_u8_x4",
    "vld1q_u8_x2",
    "vld1q_u8_x3",
    "vld1q_u8_x4",
    "vld1_u16_x2",
    "vld1_u16_x3",
    "vld1_u16_x4",
    "vld1q_u16_x2",
    "vld1q_u16_x3",
    "vld1q_u16_x4",
    "vld1_u32_x2",
    "vld1_u32_x3",
    "vld1_u32_x4",
    "vld1q_u32_x2",
    "vld1q_u32_x3",
    "vld1q_u32_x4",
    "vld1_u64_x2",
    "vld1_u64_x3",
    "vld1_u64_x4",
    "vld1q_u64_x2",
    "vld1q_u64_x3",
    "vld1q_u64_x4",
    "vld1_p8_x2",
    "vld1_p8_x3",
    "vld1_p8_x4",
    "vld1q_p8_x2",
    "vld1q_p8_x3",
    "vld1q_p8_x4",
    "vld1_p16_x2",
    "vld1_p16_x3",
    "vld1_p16_x4",
    "vld1q_p16_x2",
    "vld1q_p16_x3",
    "vld1q_p16_x4",
    "vld2_dup_f16",
    "vld2q_dup_f16",
    "vld2_dup_f16",
    "vld2q_dup_f16",
    "vld2_dup_f32",
    "vld2q_dup_f32",
    "vld2_dup_s8",
    "vld2q_dup_s8",
    "vld2_dup_s16",
    "vld2q_dup_s16",
    "vld2_dup_s32",
    "vld2q_dup_s32",
    "vld2_dup_f32",
    "vld2q_dup_f32",
    "vld2_dup_s8",
    "vld2q_dup_s8",
    "vld2_dup_s16",
    "vld2q_dup_s16",
    "vld2_dup_s32",
    "vld2q_dup_s32",
    "vld2_dup_p64",
    "vld2_dup_s64",
    "vld2_dup_s64",
    "vld2_dup_u64",
    "vld2_dup_u8",
    "vld2_dup_u8",
    "vld2q_dup_u8",
    "vld2q_dup_u8",
    "vld2_dup_u16",
    "vld2_dup_u16",
    "vld2q_dup_u16",
    "vld2q_dup_u16",
    "vld2_dup_u32",
    "vld2_dup_u32",
    "vld2q_dup_u32",
    "vld2q_dup_u32",
    "vld2_dup_p8",
    "vld2_dup_p8",
    "vld2q_dup_p8",
    "vld2q_dup_p8",
    "vld2_dup_p16",
    "vld2_dup_p16",
    "vld2q_dup_p16",
    "vld2q_dup_p16",
    "vld2_f16",
    "vld2q_f16",
    "vld2_f16",
    "vld2q_f16",
    "vld2_f32",
    "vld2q_f32",
    "vld2_s8",
    "vld2q_s8",
    "vld2_s16",
    "vld2q_s16",
    "vld2_s32",
    "vld2q_s32",
    "vld2_f32",
    "vld2q_f32",
    "vld2_s8",
    "vld2q_s8",
    "vld2_s16",
    "vld2q_s16",
    "vld2_s32",
    "vld2q_s32",
    "vld2_lane_f16",
    "vld2q_lane_f16",
    "vld2_lane_f16",
    "vld2q_lane_f16",
    "vld2_lane_f32",
    "vld2q_lane_f32",
    "vld2_lane_s8",
    "vld2_lane_s16",
    "vld2q_lane_s16",
    "vld2_lane_s32",
    "vld2q_lane_s32",
    "vld2_lane_f32",
    "vld2q_lane_f32",
    "vld2q_lane_s16",
    "vld2q_lane_s32",
    "vld2_lane_s8",
    "vld2_lane_s16",
    "vld2_lane_s32",
    "vld2_lane_u8",
    "vld2_lane_u16",
    "vld2q_lane_u16",
    "vld2_lane_u32",
    "vld2q_lane_u32",
    "vld2_lane_p8",
    "vld2_lane_p16",
    "vld2q_lane_p16",
    "vld2_p64",
    "vld2_s64",
    "vld2_s64",
    "vld2_u64",
    "vld2_u8",
    "vld2q_u8",
    "vld2_u16",
    "vld2q_u16",
    "vld2_u32",
    "vld2q_u32",
    "vld2_p8",
    "vld2q_p8",
    "vld2_p16",
    "vld2q_p16",
    "vld3_dup_f16",
    "vld3q_dup_f16",
    "vld3_dup_f16",
    "vld3q_dup_f16",
    "vld3_dup_f32",
    "vld3q_dup_f32",
    "vld3_dup_s8",
    "vld3q_dup_s8",
    "vld3_dup_s16",
    "vld3q_dup_s16",
    "vld3_dup_s32",
    "vld3q_dup_s32",
    "vld3_dup_s64",
    "vld3_dup_f32",
    "vld3q_dup_f32",
    "vld3_dup_s8",
    "vld3q_dup_s8",
    "vld3_dup_s16",
    "vld3q_dup_s16",
    "vld3_dup_s32",
    "vld3q_dup_s32",
    "vld3_dup_p64",
    "vld3_dup_s64",
    "vld3_dup_u64",
    "vld3_dup_u8",
    "vld3_dup_u8",
    "vld3q_dup_u8",
    "vld3q_dup_u8",
    "vld3_dup_u16",
    "vld3_dup_u16",
    "vld3q_dup_u16",
    "vld3q_dup_u16",
    "vld3_dup_u32",
    "vld3_dup_u32",
    "vld3q_dup_u32",
    "vld3q_dup_u32",
    "vld3_dup_p8",
    "vld3_dup_p8",
    "vld3q_dup_p8",
    "vld3q_dup_p8",
    "vld3_dup_p16",
    "vld3_dup_p16",
    "vld3q_dup_p16",
    "vld3q_dup_p16",
    "vld3_f16",
    "vld3q_f16",
    "vld3_f16",
    "vld3q_f16",
    "vld3_f32",
    "vld3q_f32",
    "vld3_s8",
    "vld3q_s8",
    "vld3_s16",
    "vld3q_s16",
    "vld3_s32",
    "vld3q_s32",
    "vld3_f32",
    "vld3q_f32",
    "vld3_s8",
    "vld3q_s8",
    "vld3_s16",
    "vld3q_s16",
    "vld3_s32",
    "vld3q_s32",
    "vld3_lane_f16",
    "vld3q_lane_f16",
    "vld3_lane_f16",
    "vld3q_lane_f16",
    "vld3_lane_f32",
    "vld3q_lane_f32",
    "vld3_lane_f32",
    "vld3_lane_s8",
    "vld3_lane_s16",
    "vld3q_lane_s16",
    "vld3_lane_s32",
    "vld3q_lane_s32",
    "vld3_lane_s8",
    "vld3_lane_s16",
    "vld3q_lane_s16",
    "vld3_lane_s32",
    "vld3q_lane_s32",
    "vld3_lane_u8",
    "vld3_lane_u16",
    "vld3q_lane_u16",
    "vld3_lane_u32",
    "vld3q_lane_u32",
    "vld3_lane_p8",
    "vld3_lane_p16",
    "vld3q_lane_p16",
    "vld3_p64",
    "vld3_s64",
    "vld3_s64",
    "vld3_u64",
    "vld3_u8",
    "vld3q_u8",
    "vld3_u16",
    "vld3q_u16",
    "vld3_u32",
    "vld3q_u32",
    "vld3_p8",
    "vld3q_p8",
    "vld3_p16",
    "vld3q_p16",
    "vld3q_lane_f32",
    "vld4_dup_f16",
    "vld4q_dup_f16",
    "vld4_dup_f16",
    "vld4q_dup_f16",
    "vld4_dup_f32",
    "vld4q_dup_f32",
    "vld4_dup_s8",
    "vld4q_dup_s8",
    "vld4_dup_s16",
    "vld4q_dup_s16",
    "vld4_dup_s32",
    "vld4q_dup_s32",
    "vld4_dup_f32",
    "vld4q_dup_f32",
    "vld4_dup_s8",
    "vld4q_dup_s8",
    "vld4_dup_s16",
    "vld4q_dup_s16",
    "vld4_dup_s32",
    "vld4q_dup_s32",
    "vld4_dup_s64",
    "vld4_dup_p64",
    "vld4_dup_s64",
    "vld4_dup_u64",
    "vld4_dup_u8",
    "vld4_dup_u8",
    "vld4q_dup_u8",
    "vld4q_dup_u8",
    "vld4_dup_u16",
    "vld4_dup_u16",
    "vld4q_dup_u16",
    "vld4q_dup_u16",
    "vld4_dup_u32",
    "vld4_dup_u32",
    "vld4q_dup_u32",
    "vld4q_dup_u32",
    "vld4_dup_p8",
    "vld4_dup_p8",
    "vld4q_dup_p8",
    "vld4q_dup_p8",
    "vld4_dup_p16",
    "vld4_dup_p16",
    "vld4q_dup_p16",
    "vld4q_dup_p16",
    "vld4_f16",
    "vld4q_f16",
    "vld4_f16",
    "vld4q_f16",
    "vld4_f32",
    "vld4q_f32",
    "vld4_s8",
    "vld4q_s8",
    "vld4_s16",
    "vld4q_s16",
    "vld4_s32",
    "vld4q_s32",
    "vld4_f32",
    "vld4q_f32",
    "vld4_s8",
    "vld4q_s8",
    "vld4_s16",
    "vld4q_s16",
    "vld4_s32",
    "vld4q_s32",
    "vld4_lane_f16",
    "vld4q_lane_f16",
    "vld4_lane_f16",
    "vld4q_lane_f16",
    "vld4_lane_f32",
    "vld4q_lane_f32",
    "vld4_lane_s8",
    "vld4_lane_s16",
    "vld4q_lane_s16",
    "vld4_lane_s32",
    "vld4q_lane_s32",
    "vld4_lane_f32",
    "vld4q_lane_f32",
    "vld4_lane_s8",
    "vld4_lane_s16",
    "vld4q_lane_s16",
    "vld4_lane_s32",
    "vld4q_lane_s32",
    "vld4_lane_u8",
    "vld4_lane_u16",
    "vld4q_lane_u16",
    "vld4_lane_u32",
    "vld4q_lane_u32",
    "vld4_lane_p8",
    "vld4_lane_p16",
    "vld4q_lane_p16",
    "vld4_p64",
    "vld4_s64",
    "vld4_s64",
    "vld4_u64",
    "vld4_u8",
    "vld4q_u8",
    "vld4_u16",
    "vld4q_u16",
    "vld4_u32",
    "vld4q_u32",
    "vld4_p8",
    "vld4q_p8",
    "vld4_p16",
    "vld4q_p16",
    "vmax_f16",
    "vmaxq_f16",
    "vmax_f32",
    "vmaxq_f32",
    "vmax_s8",
    "vmaxq_s8",
    "vmax_s16",
    "vmaxq_s16",
    "vmax_s32",
    "vmaxq_s32",
    "vmax_u8",
    "vmaxq_u8",
    "vmax_u16",
    "vmaxq_u16",
    "vmax_u32",
    "vmaxq_u32",
    "vmaxnm_f16",
    "vmaxnmq_f16",
    "vmaxnm_f32",
    "vmaxnmq_f32",
    "vmin_f16",
    "vminq_f16",
    "vmin_f32",
    "vminq_f32",
    "vmin_s8",
    "vminq_s8",
    "vmin_s16",
    "vminq_s16",
    "vmin_s32",
    "vminq_s32",
    "vmin_u8",
    "vminq_u8",
    "vmin_u16",
    "vminq_u16",
    "vmin_u32",
    "vminq_u32",
    "vminnm_f16",
    "vminnmq_f16",
    "vminnm_f32",
    "vminnmq_f32",
    "vmla_f32",
    "vmlaq_f32",
    "vmla_lane_f32",
    "vmla_laneq_f32",
    "vmlaq_lane_f32",
    "vmlaq_laneq_f32",
    "vmla_lane_s16",
    "vmla_lane_u16",
    "vmla_laneq_s16",
    "vmla_laneq_u16",
    "vmlaq_lane_s16",
    "vmlaq_lane_u16",
    "vmlaq_laneq_s16",
    "vmlaq_laneq_u16",
    "vmla_lane_s32",
    "vmla_lane_u32",
    "vmla_laneq_s32",
    "vmla_laneq_u32",
    "vmlaq_lane_s32",
    "vmlaq_lane_u32",
    "vmlaq_laneq_s32",
    "vmlaq_laneq_u32",
    "vmla_n_f32",
    "vmlaq_n_f32",
    "vmla_n_s16",
    "vmlaq_n_s16",
    "vmla_n_u16",
    "vmlaq_n_u16",
    "vmla_n_s32",
    "vmlaq_n_s32",
    "vmla_n_u32",
    "vmlaq_n_u32",
    "vmla_s8",
    "vmlaq_s8",
    "vmla_s16",
    "vmlaq_s16",
    "vmla_s32",
    "vmlaq_s32",
    "vmla_u8",
    "vmlaq_u8",
    "vmla_u16",
    "vmlaq_u16",
    "vmla_u32",
    "vmlaq_u32",
    "vmlal_lane_s16",
    "vmlal_laneq_s16",
    "vmlal_lane_s32",
    "vmlal_laneq_s32",
    "vmlal_lane_u16",
    "vmlal_laneq_u16",
    "vmlal_lane_u32",
    "vmlal_laneq_u32",
    "vmlal_n_s16",
    "vmlal_n_s32",
    "vmlal_n_u16",
    "vmlal_n_u32",
    "vmlal_s8",
    "vmlal_s16",
    "vmlal_s32",
    "vmlal_u8",
    "vmlal_u16",
    "vmlal_u32",
    "vmls_f32",
    "vmlsq_f32",
    "vmls_lane_f32",
    "vmls_laneq_f32",
    "vmlsq_lane_f32",
    "vmlsq_laneq_f32",
    "vmls_lane_s16",
    "vmls_lane_u16",
    "vmls_laneq_s16",
    "vmls_laneq_u16",
    "vmlsq_lane_s16",
    "vmlsq_lane_u16",
    "vmlsq_laneq_s16",
    "vmlsq_laneq_u16",
    "vmls_lane_s32",
    "vmls_lane_u32",
    "vmls_laneq_s32",
    "vmls_laneq_u32",
    "vmlsq_lane_s32",
    "vmlsq_lane_u32",
    "vmlsq_laneq_s32",
    "vmlsq_laneq_u32",
    "vmls_n_f32",
    "vmlsq_n_f32",
    "vmls_n_s16",
    "vmlsq_n_s16",
    "vmls_n_u16",
    "vmlsq_n_u16",
    "vmls_n_s32",
    "vmlsq_n_s32",
    "vmls_n_u32",
    "vmlsq_n_u32",
    "vmls_s8",
    "vmlsq_s8",
    "vmls_s16",
    "vmlsq_s16",
    "vmls_s32",
    "vmlsq_s32",
    "vmls_u8",
    "vmlsq_u8",
    "vmls_u16",
    "vmlsq_u16",
    "vmls_u32",
    "vmlsq_u32",
    "vmlsl_lane_s16",
    "vmlsl_laneq_s16",
    "vmlsl_lane_s32",
    "vmlsl_laneq_s32",
    "vmlsl_lane_u16",
    "vmlsl_laneq_u16",
    "vmlsl_lane_u32",
    "vmlsl_laneq_u32",
    "vmlsl_n_s16",
    "vmlsl_n_s32",
    "vmlsl_n_u16",
    "vmlsl_n_u32",
    "vmlsl_s8",
    "vmlsl_s16",
    "vmlsl_s32",
    "vmlsl_u8",
    "vmlsl_u16",
    "vmlsl_u32",
    "vmmlaq_s32",
    "vmmlaq_u32",
    "vmov_n_f16",
    "vmovq_n_f16",
    "vmul_f16",
    "vmulq_f16",
    "vmul_lane_f16",
    "vmulq_lane_f16",
    "vmul_lane_f32",
    "vmul_laneq_f32",
    "vmulq_lane_f32",
    "vmulq_laneq_f32",
    "vmul_lane_s16",
    "vmulq_lane_s16",
    "vmul_lane_s32",
    "vmulq_lane_s32",
    "vmul_lane_u16",
    "vmulq_lane_u16",
    "vmul_lane_u32",
    "vmulq_lane_u32",
    "vmul_laneq_s16",
    "vmulq_laneq_s16",
    "vmul_laneq_s32",
    "vmulq_laneq_s32",
    "vmul_laneq_u16",
    "vmulq_laneq_u16",
    "vmul_laneq_u32",
    "vmulq_laneq_u32",
    "vmul_n_f16",
    "vmulq_n_f16",
    "vmul_n_f32",
    "vmulq_n_f32",
    "vmul_n_s16",
    "vmulq_n_s16",
    "vmul_n_s32",
    "vmulq_n_s32",
    "vmul_n_u16",
    "vmulq_n_u16",
    "vmul_n_u32",
    "vmulq_n_u32",
    "vmul_p8",
    "vmulq_p8",
    "vmull_lane_s16",
    "vmull_laneq_s16",
    "vmull_lane_s32",
    "vmull_laneq_s32",
    "vmull_lane_u16",
    "vmull_laneq_u16",
    "vmull_lane_u32",
    "vmull_laneq_u32",
    "vmull_n_s16",
    "vmull_n_s32",
    "vmull_n_u16",
    "vmull_n_u32",
    "vmull_p8",
    "vmull_s16",
    "vmull_s32",
    "vmull_s8",
    "vmull_u8",
    "vmull_u16",
    "vmull_u32",
    "vneg_f16",
    "vnegq_f16",
    "vneg_f32",
    "vnegq_f32",
    "vneg_s8",
    "vnegq_s8",
    "vneg_s16",
    "vnegq_s16",
    "vneg_s32",
    "vnegq_s32",
    "vpadal_s8",
    "vpadalq_s8",
    "vpadal_s16",
    "vpadalq_s16",
    "vpadal_s32",
    "vpadalq_s32",
    "vpadal_u8",
    "vpadalq_u8",
    "vpadal_u16",
    "vpadalq_u16",
    "vpadal_u32",
    "vpadalq_u32",
    "vpadd_f16",
    "vpadd_f32",
    "vpadd_s8",
    "vpadd_s16",
    "vpadd_s32",
    "vpadd_u8",
    "vpadd_u8",
    "vpadd_u16",
    "vpadd_u16",
    "vpadd_u32",
    "vpadd_u32",
    "vpaddl_s8",
    "vpaddlq_s8",
    "vpaddl_s16",
    "vpaddlq_s16",
    "vpaddl_s32",
    "vpaddlq_s32",
    "vpaddl_u8",
    "vpaddlq_u8",
    "vpaddl_u16",
    "vpaddlq_u16",
    "vpaddl_u32",
    "vpaddlq_u32",
    "vpmax_f32",
    "vpmax_s8",
    "vpmax_s16",
    "vpmax_s32",
    "vpmax_u8",
    "vpmax_u16",
    "vpmax_u32",
    "vpmin_f32",
    "vpmin_s8",
    "vpmin_s16",
    "vpmin_s32",
    "vpmin_u8",
    "vpmin_u16",
    "vpmin_u32",
    "vqabs_s8",
    "vqabsq_s8",
    "vqabs_s16",
    "vqabsq_s16",
    "vqabs_s32",
    "vqabsq_s32",
    "vqadd_s64",
    "vqaddq_s64",
    "vqadd_u64",
    "vqaddq_u64",
    "vqdmlal_lane_s16",
    "vqdmlal_lane_s32",
    "vqdmlal_n_s16",
    "vqdmlal_n_s32",
    "vqdmlal_s16",
    "vqdmlal_s32",
    "vqdmlsl_lane_s16",
    "vqdmlsl_lane_s32",
    "vqdmlsl_n_s16",
    "vqdmlsl_n_s32",
    "vqdmlsl_s16",
    "vqdmlsl_s32",
    "vqdmulh_laneq_s16",
    "vqdmulhq_laneq_s16",
    "vqdmulh_laneq_s32",
    "vqdmulhq_laneq_s32",
    "vqdmulh_n_s16",
    "vqdmulhq_n_s16",
    "vqdmulh_n_s32",
    "vqdmulhq_n_s32",
    "vqdmulh_s16",
    "vqdmulhq_s16",
    "vqdmulh_s32",
    "vqdmulhq_s32",
    "vqdmull_lane_s16",
    "vqdmull_lane_s32",
    "vqdmull_n_s16",
    "vqdmull_n_s32",
    "vqdmull_s16",
    "vqdmull_s32",
    "vqmovn_s16",
    "vqmovn_s32",
    "vqmovn_s64",
    "vqmovn_u16",
    "vqmovn_u32",
    "vqmovn_u64",
    "vqmovun_s16",
    "vqmovun_s32",
    "vqmovun_s64",
    "vqneg_s8",
    "vqnegq_s8",
    "vqneg_s16",
    "vqnegq_s16",
    "vqneg_s32",
    "vqnegq_s32",
    "vqrdmulh_lane_s16",
    "vqrdmulh_lane_s32",
    "vqrdmulh_laneq_s16",
    "vqrdmulh_laneq_s32",
    "vqrdmulhq_lane_s16",
    "vqrdmulhq_lane_s32",
    "vqrdmulhq_laneq_s16",
    "vqrdmulhq_laneq_s32",
    "vqrdmulh_n_s16",
    "vqrdmulhq_n_s16",
    "vqrdmulh_n_s32",
    "vqrdmulhq_n_s32",
    "vqrdmulh_s16",
    "vqrdmulhq_s16",
    "vqrdmulh_s32",
    "vqrdmulhq_s32",
    "vqrshl_s8",
    "vqrshlq_s8",
    "vqrshl_s16",
    "vqrshlq_s16",
    "vqrshl_s32",
    "vqrshlq_s32",
    "vqrshl_s64",
    "vqrshlq_s64",
    "vqrshl_u8",
    "vqrshlq_u8",
    "vqrshl_u16",
    "vqrshlq_u16",
    "vqrshl_u32",
    "vqrshlq_u32",
    "vqrshl_u64",
    "vqrshlq_u64",
    "vqrshrn_n_s16",
    "vqrshrn_n_s32",
    "vqrshrn_n_s64",
    "vqrshrn_n_s16",
    "vqrshrn_n_s32",
    "vqrshrn_n_s64",
    "vqrshrn_n_u16",
    "vqrshrn_n_u32",
    "vqrshrn_n_u64",
    "vqrshrn_n_u16",
    "vqrshrn_n_u32",
    "vqrshrn_n_u64",
    "vqrshrun_n_s16",
    "vqrshrun_n_s32",
    "vqrshrun_n_s64",
    "vqrshrun_n_s16",
    "vqrshrun_n_s32",
    "vqrshrun_n_s64",
    "vqshl_n_s8",
    "vqshlq_n_s8",
    "vqshl_n_s16",
    "vqshlq_n_s16",
    "vqshl_n_s32",
    "vqshlq_n_s32",
    "vqshl_n_s64",
    "vqshlq_n_s64",
    "vqshl_n_u8",
    "vqshlq_n_u8",
    "vqshl_n_u16",
    "vqshlq_n_u16",
    "vqshl_n_u32",
    "vqshlq_n_u32",
    "vqshl_n_u64",
    "vqshlq_n_u64",
    "vqshl_s8",
    "vqshlq_s8",
    "vqshl_s16",
    "vqshlq_s16",
    "vqshl_s32",
    "vqshlq_s32",
    "vqshl_s64",
    "vqshlq_s64",
    "vqshl_u8",
    "vqshlq_u8",
    "vqshl_u16",
    "vqshlq_u16",
    "vqshl_u32",
    "vqshlq_u32",
    "vqshl_u64",
    "vqshlq_u64",
    "vqshlu_n_s8",
    "vqshluq_n_s8",
    "vqshlu_n_s16",
    "vqshluq_n_s16",
    "vqshlu_n_s32",
    "vqshluq_n_s32",
    "vqshlu_n_s64",
    "vqshluq_n_s64",
    "vqshlu_n_s8",
    "vqshluq_n_s8",
    "vqshlu_n_s16",
    "vqshluq_n_s16",
    "vqshlu_n_s32",
    "vqshluq_n_s32",
    "vqshlu_n_s64",
    "vqshluq_n_s64",
    "vqshrn_n_s16",
    "vqshrn_n_s32",
    "vqshrn_n_s64",
    "vqshrn_n_s16",
    "vqshrn_n_s32",
    "vqshrn_n_s64",
    "vqshrn_n_u16",
    "vqshrn_n_u32",
    "vqshrn_n_u64",
    "vqshrn_n_u16",
    "vqshrn_n_u32",
    "vqshrn_n_u64",
    "vqshrun_n_s16",
    "vqshrun_n_s32",
    "vqshrun_n_s64",
    "vqshrun_n_s16",
    "vqshrun_n_s32",
    "vqshrun_n_s64",
    "vqsub_s64",
    "vqsubq_s64",
    "vqsub_u64",
    "vqsubq_u64",
    "vraddhn_high_s16",
    "vraddhn_high_s32",
    "vraddhn_high_s64",
    "vraddhn_high_u16",
    "vraddhn_high_u32",
    "vraddhn_high_u64",
    "vraddhn_s16",
    "vraddhn_s32",
    "vraddhn_s64",
    "vraddhn_u16",
    "vraddhn_u16",
    "vraddhn_u32",
    "vraddhn_u32",
    "vraddhn_u64",
    "vraddhn_u64",
    "vrecpe_f16",
    "vrecpeq_f16",
    "vrecpe_f32",
    "vrecpeq_f32",
    "vrecpe_u32",
    "vrecpeq_u32",
    "vrecps_f16",
    "vrecpsq_f16",
    "vrecps_f32",
    "vrecpsq_f32",
    "vreinterpret_f32_f16",
    "vreinterpret_f32_f16",
    "vreinterpret_s8_f16",
    "vreinterpret_s8_f16",
    "vreinterpret_s16_f16",
    "vreinterpret_s16_f16",
    "vreinterpret_s32_f16",
    "vreinterpret_s32_f16",
    "vreinterpret_s64_f16",
    "vreinterpret_s64_f16",
    "vreinterpret_u8_f16",
    "vreinterpret_u8_f16",
    "vreinterpret_u16_f16",
    "vreinterpret_u16_f16",
    "vreinterpret_u32_f16",
    "vreinterpret_u32_f16",
    "vreinterpret_u64_f16",
    "vreinterpret_u64_f16",
    "vreinterpret_p8_f16",
    "vreinterpret_p8_f16",
    "vreinterpret_p16_f16",
    "vreinterpret_p16_f16",
    "vreinterpretq_f32_f16",
    "vreinterpretq_f32_f16",
    "vreinterpretq_s8_f16",
    "vreinterpretq_s8_f16",
    "vreinterpretq_s16_f16",
    "vreinterpretq_s16_f16",
    "vreinterpretq_s32_f16",
    "vreinterpretq_s32_f16",
    "vreinterpretq_s64_f16",
    "vreinterpretq_s64_f16",
    "vreinterpretq_u8_f16",
    "vreinterpretq_u8_f16",
    "vreinterpretq_u16_f16",
    "vreinterpretq_u16_f16",
    "vreinterpretq_u32_f16",
    "vreinterpretq_u32_f16",
    "vreinterpretq_u64_f16",
    "vreinterpretq_u64_f16",
    "vreinterpretq_p8_f16",
    "vreinterpretq_p8_f16",
    "vreinterpretq_p16_f16",
    "vreinterpretq_p16_f16",
    "vreinterpret_f16_f32",
    "vreinterpret_f16_f32",
    "vreinterpretq_f16_f32",
    "vreinterpretq_f16_f32",
    "vreinterpret_f16_s8",
    "vreinterpret_f16_s8",
    "vreinterpretq_f16_s8",
    "vreinterpretq_f16_s8",
    "vreinterpret_f16_s16",
    "vreinterpret_f16_s16",
    "vreinterpretq_f16_s16",
    "vreinterpretq_f16_s16",
    "vreinterpret_f16_s32",
    "vreinterpret_f16_s32",
    "vreinterpretq_f16_s32",
    "vreinterpretq_f16_s32",
    "vreinterpret_f16_s64",
    "vreinterpret_f16_s64",
    "vreinterpretq_f16_s64",
    "vreinterpretq_f16_s64",
    "vreinterpret_f16_u8",
    "vreinterpret_f16_u8",
    "vreinterpretq_f16_u8",
    "vreinterpretq_f16_u8",
    "vreinterpret_f16_u16",
    "vreinterpret_f16_u16",
    "vreinterpretq_f16_u16",
    "vreinterpretq_f16_u16",
    "vreinterpret_f16_u32",
    "vreinterpret_f16_u32",
    "vreinterpretq_f16_u32",
    "vreinterpretq_f16_u32",
    "vreinterpret_f16_u64",
    "vreinterpret_f16_u64",
    "vreinterpretq_f16_u64",
    "vreinterpretq_f16_u64",
    "vreinterpret_f16_p8",
    "vreinterpret_f16_p8",
    "vreinterpretq_f16_p8",
    "vreinterpretq_f16_p8",
    "vreinterpret_f16_p16",
    "vreinterpret_f16_p16",
    "vreinterpretq_f16_p16",
    "vreinterpretq_f16_p16",
    "vreinterpretq_f16_p128",
    "vreinterpretq_f16_p128",
    "vreinterpret_p64_f16",
    "vreinterpret_p64_f16",
    "vreinterpretq_p128_f16",
    "vreinterpretq_p128_f16",
    "vreinterpretq_p64_f16",
    "vreinterpretq_p64_f16",
    "vreinterpret_f16_p64",
    "vreinterpret_f16_p64",
    "vreinterpretq_f16_p64",
    "vreinterpretq_f16_p64",
    "vreinterpretq_f32_p128",
    "vreinterpretq_f32_p128",
    "vreinterpret_s8_f32",
    "vreinterpret_s8_f32",
    "vreinterpret_s16_f32",
    "vreinterpret_s16_f32",
    "vreinterpret_s32_f32",
    "vreinterpret_s32_f32",
    "vreinterpret_s64_f32",
    "vreinterpret_s64_f32",
    "vreinterpret_u8_f32",
    "vreinterpret_u8_f32",
    "vreinterpret_u16_f32",
    "vreinterpret_u16_f32",
    "vreinterpret_u32_f32",
    "vreinterpret_u32_f32",
    "vreinterpret_u64_f32",
    "vreinterpret_u64_f32",
    "vreinterpret_p8_f32",
    "vreinterpret_p8_f32",
    "vreinterpret_p16_f32",
    "vreinterpret_p16_f32",
    "vreinterpretq_p128_f32",
    "vreinterpretq_p128_f32",
    "vreinterpretq_s8_f32",
    "vreinterpretq_s8_f32",
    "vreinterpretq_s16_f32",
    "vreinterpretq_s16_f32",
    "vreinterpretq_s32_f32",
    "vreinterpretq_s32_f32",
    "vreinterpretq_s64_f32",
    "vreinterpretq_s64_f32",
    "vreinterpretq_u8_f32",
    "vreinterpretq_u8_f32",
    "vreinterpretq_u16_f32",
    "vreinterpretq_u16_f32",
    "vreinterpretq_u32_f32",
    "vreinterpretq_u32_f32",
    "vreinterpretq_u64_f32",
    "vreinterpretq_u64_f32",
    "vreinterpretq_p8_f32",
    "vreinterpretq_p8_f32",
    "vreinterpretq_p16_f32",
    "vreinterpretq_p16_f32",
    "vreinterpret_f32_s8",
    "vreinterpret_f32_s8",
    "vreinterpret_s16_s8",
    "vreinterpret_s16_s8",
    "vreinterpret_s32_s8",
    "vreinterpret_s32_s8",
    "vreinterpret_s64_s8",
    "vreinterpret_s64_s8",
    "vreinterpret_u8_s8",
    "vreinterpret_u8_s8",
    "vreinterpret_u16_s8",
    "vreinterpret_u16_s8",
    "vreinterpret_u32_s8",
    "vreinterpret_u32_s8",
    "vreinterpret_u64_s8",
    "vreinterpret_u64_s8",
    "vreinterpret_p8_s8",
    "vreinterpret_p8_s8",
    "vreinterpret_p16_s8",
    "vreinterpret_p16_s8",
    "vreinterpretq_f32_s8",
    "vreinterpretq_f32_s8",
    "vreinterpretq_s16_s8",
    "vreinterpretq_s16_s8",
    "vreinterpretq_s32_s8",
    "vreinterpretq_s32_s8",
    "vreinterpretq_s64_s8",
    "vreinterpretq_s64_s8",
    "vreinterpretq_u8_s8",
    "vreinterpretq_u8_s8",
    "vreinterpretq_u16_s8",
    "vreinterpretq_u16_s8",
    "vreinterpretq_u32_s8",
    "vreinterpretq_u32_s8",
    "vreinterpretq_u64_s8",
    "vreinterpretq_u64_s8",
    "vreinterpretq_p8_s8",
    "vreinterpretq_p8_s8",
    "vreinterpretq_p16_s8",
    "vreinterpretq_p16_s8",
    "vreinterpret_f32_s16",
    "vreinterpret_f32_s16",
    "vreinterpret_s8_s16",
    "vreinterpret_s8_s16",
    "vreinterpret_s32_s16",
    "vreinterpret_s32_s16",
    "vreinterpret_s64_s16",
    "vreinterpret_s64_s16",
    "vreinterpret_u8_s16",
    "vreinterpret_u8_s16",
    "vreinterpret_u16_s16",
    "vreinterpret_u16_s16",
    "vreinterpret_u32_s16",
    "vreinterpret_u32_s16",
    "vreinterpret_u64_s16",
    "vreinterpret_u64_s16",
    "vreinterpret_p8_s16",
    "vreinterpret_p8_s16",
    "vreinterpret_p16_s16",
    "vreinterpret_p16_s16",
    "vreinterpretq_f32_s16",
    "vreinterpretq_f32_s16",
    "vreinterpretq_s8_s16",
    "vreinterpretq_s8_s16",
    "vreinterpretq_s32_s16",
    "vreinterpretq_s32_s16",
    "vreinterpretq_s64_s16",
    "vreinterpretq_s64_s16",
    "vreinterpretq_u8_s16",
    "vreinterpretq_u8_s16",
    "vreinterpretq_u16_s16",
    "vreinterpretq_u16_s16",
    "vreinterpretq_u32_s16",
    "vreinterpretq_u32_s16",
    "vreinterpretq_u64_s16",
    "vreinterpretq_u64_s16",
    "vreinterpretq_p8_s16",
    "vreinterpretq_p8_s16",
    "vreinterpretq_p16_s16",
    "vreinterpretq_p16_s16",
    "vreinterpret_f32_s32",
    "vreinterpret_f32_s32",
    "vreinterpret_s8_s32",
    "vreinterpret_s8_s32",
    "vreinterpret_s16_s32",
    "vreinterpret_s16_s32",
    "vreinterpret_s64_s32",
    "vreinterpret_s64_s32",
    "vreinterpret_u8_s32",
    "vreinterpret_u8_s32",
    "vreinterpret_u16_s32",
    "vreinterpret_u16_s32",
    "vreinterpret_u32_s32",
    "vreinterpret_u32_s32",
    "vreinterpret_u64_s32",
    "vreinterpret_u64_s32",
    "vreinterpret_p8_s32",
    "vreinterpret_p8_s32",
    "vreinterpret_p16_s32",
    "vreinterpret_p16_s32",
    "vreinterpretq_f32_s32",
    "vreinterpretq_f32_s32",
    "vreinterpretq_s8_s32",
    "vreinterpretq_s8_s32",
    "vreinterpretq_s16_s32",
    "vreinterpretq_s16_s32",
    "vreinterpretq_s64_s32",
    "vreinterpretq_s64_s32",
    "vreinterpretq_u8_s32",
    "vreinterpretq_u8_s32",
    "vreinterpretq_u16_s32",
    "vreinterpretq_u16_s32",
    "vreinterpretq_u32_s32",
    "vreinterpretq_u32_s32",
    "vreinterpretq_u64_s32",
    "vreinterpretq_u64_s32",
    "vreinterpretq_p8_s32",
    "vreinterpretq_p8_s32",
    "vreinterpretq_p16_s32",
    "vreinterpretq_p16_s32",
    "vreinterpret_f32_s64",
    "vreinterpret_f32_s64",
    "vreinterpret_s8_s64",
    "vreinterpret_s8_s64",
    "vreinterpret_s16_s64",
    "vreinterpret_s16_s64",
    "vreinterpret_s32_s64",
    "vreinterpret_s32_s64",
    "vreinterpret_u8_s64",
    "vreinterpret_u8_s64",
    "vreinterpret_u16_s64",
    "vreinterpret_u16_s64",
    "vreinterpret_u32_s64",
    "vreinterpret_u32_s64",
    "vreinterpret_u64_s64",
    "vreinterpret_p8_s64",
    "vreinterpret_p8_s64",
    "vreinterpret_p16_s64",
    "vreinterpret_p16_s64",
    "vreinterpretq_f32_s64",
    "vreinterpretq_f32_s64",
    "vreinterpretq_s8_s64",
    "vreinterpretq_s8_s64",
    "vreinterpretq_s16_s64",
    "vreinterpretq_s16_s64",
    "vreinterpretq_s32_s64",
    "vreinterpretq_s32_s64",
    "vreinterpretq_u8_s64",
    "vreinterpretq_u8_s64",
    "vreinterpretq_u16_s64",
    "vreinterpretq_u16_s64",
    "vreinterpretq_u32_s64",
    "vreinterpretq_u32_s64",
    "vreinterpretq_u64_s64",
    "vreinterpretq_u64_s64",
    "vreinterpretq_p8_s64",
    "vreinterpretq_p8_s64",
    "vreinterpretq_p16_s64",
    "vreinterpretq_p16_s64",
    "vreinterpret_f32_u8",
    "vreinterpret_f32_u8",
    "vreinterpret_s8_u8",
    "vreinterpret_s8_u8",
    "vreinterpret_s16_u8",
    "vreinterpret_s16_u8",
    "vreinterpret_s32_u8",
    "vreinterpret_s32_u8",
    "vreinterpret_s64_u8",
    "vreinterpret_s64_u8",
    "vreinterpret_u16_u8",
    "vreinterpret_u16_u8",
    "vreinterpret_u32_u8",
    "vreinterpret_u32_u8",
    "vreinterpret_u64_u8",
    "vreinterpret_u64_u8",
    "vreinterpret_p8_u8",
    "vreinterpret_p8_u8",
    "vreinterpret_p16_u8",
    "vreinterpret_p16_u8",
    "vreinterpretq_f32_u8",
    "vreinterpretq_f32_u8",
    "vreinterpretq_s8_u8",
    "vreinterpretq_s8_u8",
    "vreinterpretq_s16_u8",
    "vreinterpretq_s16_u8",
    "vreinterpretq_s32_u8",
    "vreinterpretq_s32_u8",
    "vreinterpretq_s64_u8",
    "vreinterpretq_s64_u8",
    "vreinterpretq_u16_u8",
    "vreinterpretq_u16_u8",
    "vreinterpretq_u32_u8",
    "vreinterpretq_u32_u8",
    "vreinterpretq_u64_u8",
    "vreinterpretq_u64_u8",
    "vreinterpretq_p8_u8",
    "vreinterpretq_p8_u8",
    "vreinterpretq_p16_u8",
    "vreinterpretq_p16_u8",
    "vreinterpret_f32_u16",
    "vreinterpret_f32_u16",
    "vreinterpret_s8_u16",
    "vreinterpret_s8_u16",
    "vreinterpret_s16_u16",
    "vreinterpret_s16_u16",
    "vreinterpret_s32_u16",
    "vreinterpret_s32_u16",
    "vreinterpret_s64_u16",
    "vreinterpret_s64_u16",
    "vreinterpret_u8_u16",
    "vreinterpret_u8_u16",
    "vreinterpret_u32_u16",
    "vreinterpret_u32_u16",
    "vreinterpret_u64_u16",
    "vreinterpret_u64_u16",
    "vreinterpret_p8_u16",
    "vreinterpret_p8_u16",
    "vreinterpret_p16_u16",
    "vreinterpret_p16_u16",
    "vreinterpretq_f32_u16",
    "vreinterpretq_f32_u16",
    "vreinterpretq_s8_u16",
    "vreinterpretq_s8_u16",
    "vreinterpretq_s16_u16",
    "vreinterpretq_s16_u16",
    "vreinterpretq_s32_u16",
    "vreinterpretq_s32_u16",
    "vreinterpretq_s64_u16",
    "vreinterpretq_s64_u16",
    "vreinterpretq_u8_u16",
    "vreinterpretq_u8_u16",
    "vreinterpretq_u32_u16",
    "vreinterpretq_u32_u16",
    "vreinterpretq_u64_u16",
    "vreinterpretq_u64_u16",
    "vreinterpretq_p8_u16",
    "vreinterpretq_p8_u16",
    "vreinterpretq_p16_u16",
    "vreinterpretq_p16_u16",
    "vreinterpret_f32_u32",
    "vreinterpret_f32_u32",
    "vreinterpret_s8_u32",
    "vreinterpret_s8_u32",
    "vreinterpret_s16_u32",
    "vreinterpret_s16_u32",
    "vreinterpret_s32_u32",
    "vreinterpret_s32_u32",
    "vreinterpret_s64_u32",
    "vreinterpret_s64_u32",
    "vreinterpret_u8_u32",
    "vreinterpret_u8_u32",
    "vreinterpret_u16_u32",
    "vreinterpret_u16_u32",
    "vreinterpret_u64_u32",
    "vreinterpret_u64_u32",
    "vreinterpret_p8_u32",
    "vreinterpret_p8_u32",
    "vreinterpret_p16_u32",
    "vreinterpret_p16_u32",
    "vreinterpretq_f32_u32",
    "vreinterpretq_f32_u32",
    "vreinterpretq_s8_u32",
    "vreinterpretq_s8_u32",
    "vreinterpretq_s16_u32",
    "vreinterpretq_s16_u32",
    "vreinterpretq_s32_u32",
    "vreinterpretq_s32_u32",
    "vreinterpretq_s64_u32",
    "vreinterpretq_s64_u32",
    "vreinterpretq_u8_u32",
    "vreinterpretq_u8_u32",
    "vreinterpretq_u16_u32",
    "vreinterpretq_u16_u32",
    "vreinterpretq_u64_u32",
    "vreinterpretq_u64_u32",
    "vreinterpretq_p8_u32",
    "vreinterpretq_p8_u32",
    "vreinterpretq_p16_u32",
    "vreinterpretq_p16_u32",
    "vreinterpret_f32_u64",
    "vreinterpret_f32_u64",
    "vreinterpret_s8_u64",
    "vreinterpret_s8_u64",
    "vreinterpret_s16_u64",
    "vreinterpret_s16_u64",
    "vreinterpret_s32_u64",
    "vreinterpret_s32_u64",
    "vreinterpret_s64_u64",
    "vreinterpret_u8_u64",
    "vreinterpret_u8_u64",
    "vreinterpret_u16_u64",
    "vreinterpret_u16_u64",
    "vreinterpret_u32_u64",
    "vreinterpret_u32_u64",
    "vreinterpret_p8_u64",
    "vreinterpret_p8_u64",
    "vreinterpret_p16_u64",
    "vreinterpret_p16_u64",
    "vreinterpretq_f32_u64",
    "vreinterpretq_f32_u64",
    "vreinterpretq_s8_u64",
    "vreinterpretq_s8_u64",
    "vreinterpretq_s16_u64",
    "vreinterpretq_s16_u64",
    "vreinterpretq_s32_u64",
    "vreinterpretq_s32_u64",
    "vreinterpretq_s64_u64",
    "vreinterpretq_s64_u64",
    "vreinterpretq_u8_u64",
    "vreinterpretq_u8_u64",
    "vreinterpretq_u16_u64",
    "vreinterpretq_u16_u64",
    "vreinterpretq_u32_u64",
    "vreinterpretq_u32_u64",
    "vreinterpretq_p8_u64",
    "vreinterpretq_p8_u64",
    "vreinterpretq_p16_u64",
    "vreinterpretq_p16_u64",
    "vreinterpret_f32_p8",
    "vreinterpret_f32_p8",
    "vreinterpret_s8_p8",
    "vreinterpret_s8_p8",
    "vreinterpret_s16_p8",
    "vreinterpret_s16_p8",
    "vreinterpret_s32_p8",
    "vreinterpret_s32_p8",
    "vreinterpret_s64_p8",
    "vreinterpret_s64_p8",
    "vreinterpret_u8_p8",
    "vreinterpret_u8_p8",
    "vreinterpret_u16_p8",
    "vreinterpret_u16_p8",
    "vreinterpret_u32_p8",
    "vreinterpret_u32_p8",
    "vreinterpret_u64_p8",
    "vreinterpret_u64_p8",
    "vreinterpret_p16_p8",
    "vreinterpret_p16_p8",
    "vreinterpretq_f32_p8",
    "vreinterpretq_f32_p8",
    "vreinterpretq_s8_p8",
    "vreinterpretq_s8_p8",
    "vreinterpretq_s16_p8",
    "vreinterpretq_s16_p8",
    "vreinterpretq_s32_p8",
    "vreinterpretq_s32_p8",
    "vreinterpretq_s64_p8",
    "vreinterpretq_s64_p8",
    "vreinterpretq_u8_p8",
    "vreinterpretq_u8_p8",
    "vreinterpretq_u16_p8",
    "vreinterpretq_u16_p8",
    "vreinterpretq_u32_p8",
    "vreinterpretq_u32_p8",
    "vreinterpretq_u64_p8",
    "vreinterpretq_u64_p8",
    "vreinterpretq_p16_p8",
    "vreinterpretq_p16_p8",
    "vreinterpret_f32_p16",
    "vreinterpret_f32_p16",
    "vreinterpret_s8_p16",
    "vreinterpret_s8_p16",
    "vreinterpret_s16_p16",
    "vreinterpret_s16_p16",
    "vreinterpret_s32_p16",
    "vreinterpret_s32_p16",
    "vreinterpret_s64_p16",
    "vreinterpret_s64_p16",
    "vreinterpret_u8_p16",
    "vreinterpret_u8_p16",
    "vreinterpret_u16_p16",
    "vreinterpret_u16_p16",
    "vreinterpret_u32_p16",
    "vreinterpret_u32_p16",
    "vreinterpret_u64_p16",
    "vreinterpret_u64_p16",
    "vreinterpret_p8_p16",
    "vreinterpret_p8_p16",
    "vreinterpretq_f32_p16",
    "vreinterpretq_f32_p16",
    "vreinterpretq_s8_p16",
    "vreinterpretq_s8_p16",
    "vreinterpretq_s16_p16",
    "vreinterpretq_s16_p16",
    "vreinterpretq_s32_p16",
    "vreinterpretq_s32_p16",
    "vreinterpretq_s64_p16",
    "vreinterpretq_s64_p16",
    "vreinterpretq_u8_p16",
    "vreinterpretq_u8_p16",
    "vreinterpretq_u16_p16",
    "vreinterpretq_u16_p16",
    "vreinterpretq_u32_p16",
    "vreinterpretq_u32_p16",
    "vreinterpretq_u64_p16",
    "vreinterpretq_u64_p16",
    "vreinterpretq_p8_p16",
    "vreinterpretq_p8_p16",
    "vreinterpretq_s8_p128",
    "vreinterpretq_s8_p128",
    "vreinterpretq_s16_p128",
    "vreinterpretq_s16_p128",
    "vreinterpretq_s32_p128",
    "vreinterpretq_s32_p128",
    "vreinterpretq_s64_p128",
    "vreinterpretq_s64_p128",
    "vreinterpretq_u8_p128",
    "vreinterpretq_u8_p128",
    "vreinterpretq_u16_p128",
    "vreinterpretq_u16_p128",
    "vreinterpretq_u32_p128",
    "vreinterpretq_u32_p128",
    "vreinterpretq_u64_p128",
    "vreinterpretq_u64_p128",
    "vreinterpretq_p8_p128",
    "vreinterpretq_p8_p128",
    "vreinterpretq_p16_p128",
    "vreinterpretq_p16_p128",
    "vreinterpretq_p64_p128",
    "vreinterpretq_p64_p128",
    "vreinterpret_p64_s8",
    "vreinterpret_p64_s8",
    "vreinterpretq_p128_s8",
    "vreinterpretq_p128_s8",
    "vreinterpretq_p64_s8",
    "vreinterpretq_p64_s8",
    "vreinterpret_p64_s16",
    "vreinterpret_p64_s16",
    "vreinterpretq_p128_s16",
    "vreinterpretq_p128_s16",
    "vreinterpretq_p64_s16",
    "vreinterpretq_p64_s16",
    "vreinterpret_p64_s32",
    "vreinterpret_p64_s32",
    "vreinterpretq_p128_s32",
    "vreinterpretq_p128_s32",
    "vreinterpretq_p64_s32",
    "vreinterpretq_p64_s32",
    "vreinterpretq_p128_s64",
    "vreinterpretq_p128_s64",
    "vreinterpret_p64_u8",
    "vreinterpret_p64_u8",
    "vreinterpretq_p128_u8",
    "vreinterpretq_p128_u8",
    "vreinterpretq_p64_u8",
    "vreinterpretq_p64_u8",
    "vreinterpret_p64_u16",
    "vreinterpret_p64_u16",
    "vreinterpretq_p128_u16",
    "vreinterpretq_p128_u16",
    "vreinterpretq_p64_u16",
    "vreinterpretq_p64_u16",
    "vreinterpret_p64_u32",
    "vreinterpret_p64_u32",
    "vreinterpretq_p128_u32",
    "vreinterpretq_p128_u32",
    "vreinterpretq_p64_u32",
    "vreinterpretq_p64_u32",
    "vreinterpretq_p128_u64",
    "vreinterpretq_p128_u64",
    "vreinterpret_p64_p8",
    "vreinterpret_p64_p8",
    "vreinterpretq_p128_p8",
    "vreinterpretq_p128_p8",
    "vreinterpretq_p64_p8",
    "vreinterpretq_p64_p8",
    "vreinterpret_p64_p16",
    "vreinterpret_p64_p16",
    "vreinterpretq_p128_p16",
    "vreinterpretq_p128_p16",
    "vreinterpretq_p64_p16",
    "vreinterpretq_p64_p16",
    "vreinterpret_s8_p64",
    "vreinterpret_s8_p64",
    "vreinterpret_s16_p64",
    "vreinterpret_s16_p64",
    "vreinterpret_s32_p64",
    "vreinterpret_s32_p64",
    "vreinterpret_u8_p64",
    "vreinterpret_u8_p64",
    "vreinterpret_u16_p64",
    "vreinterpret_u16_p64",
    "vreinterpret_u32_p64",
    "vreinterpret_u32_p64",
    "vreinterpret_p8_p64",
    "vreinterpret_p8_p64",
    "vreinterpret_p16_p64",
    "vreinterpret_p16_p64",
    "vreinterpretq_p128_p64",
    "vreinterpretq_p128_p64",
    "vreinterpretq_s8_p64",
    "vreinterpretq_s8_p64",
    "vreinterpretq_s16_p64",
    "vreinterpretq_s16_p64",
    "vreinterpretq_s32_p64",
    "vreinterpretq_s32_p64",
    "vreinterpretq_u8_p64",
    "vreinterpretq_u8_p64",
    "vreinterpretq_u16_p64",
    "vreinterpretq_u16_p64",
    "vreinterpretq_u32_p64",
    "vreinterpretq_u32_p64",
    "vreinterpretq_p8_p64",
    "vreinterpretq_p8_p64",
    "vreinterpretq_p16_p64",
    "vreinterpretq_p16_p64",
    "vrev64_f16",
    "vrev64q_f16",
    "vrndn_f16",
    "vrndnq_f16",
    "vrndn_f32",
    "vrndnq_f32",
    "vrshl_s8",
    "vrshlq_s8",
    "vrshl_s16",
    "vrshlq_s16",
    "vrshl_s32",
    "vrshlq_s32",
    "vrshl_s64",
    "vrshlq_s64",
    "vrshl_u8",
    "vrshlq_u8",
    "vrshl_u16",
    "vrshlq_u16",
    "vrshl_u32",
    "vrshlq_u32",
    "vrshl_u64",
    "vrshlq_u64",
    "vrshr_n_s8",
    "vrshrq_n_s8",
    "vrshr_n_s16",
    "vrshrq_n_s16",
    "vrshr_n_s32",
    "vrshrq_n_s32",
    "vrshr_n_s64",
    "vrshrq_n_s64",
    "vrshr_n_u8",
    "vrshrq_n_u8",
    "vrshr_n_u16",
    "vrshrq_n_u16",
    "vrshr_n_u32",
    "vrshrq_n_u32",
    "vrshr_n_u64",
    "vrshrq_n_u64",
    "vrshrn_n_s16",
    "vrshrn_n_s32",
    "vrshrn_n_s64",
    "vrshrn_n_s16",
    "vrshrn_n_s32",
    "vrshrn_n_s64",
    "vrshrn_n_u16",
    "vrshrn_n_u32",
    "vrshrn_n_u64",
    "vrsqrte_f16",
    "vrsqrteq_f16",
    "vrsqrteq_f32",
    "vrsqrte_u32",
    "vrsqrteq_u32",
    "vrsqrts_f16",
    "vrsqrtsq_f16",
    "vrsqrts_f32",
    "vrsqrtsq_f32",
    "vrsra_n_s8",
    "vrsraq_n_s8",
    "vrsra_n_s16",
    "vrsraq_n_s16",
    "vrsra_n_s32",
    "vrsraq_n_s32",
    "vrsra_n_s64",
    "vrsraq_n_s64",
    "vrsra_n_u8",
    "vrsraq_n_u8",
    "vrsra_n_u16",
    "vrsraq_n_u16",
    "vrsra_n_u32",
    "vrsraq_n_u32",
    "vrsra_n_u64",
    "vrsraq_n_u64",
    "vrsubhn_s16",
    "vrsubhn_s32",
    "vrsubhn_s64",
    "vrsubhn_u16",
    "vrsubhn_u16",
    "vrsubhn_u32",
    "vrsubhn_u32",
    "vrsubhn_u64",
    "vrsubhn_u64",
    "vset_lane_f16",
    "vsetq_lane_f16",
    "vset_lane_f32",
    "vsetq_lane_f32",
    "vset_lane_s8",
    "vsetq_lane_s8",
    "vset_lane_s16",
    "vsetq_lane_s16",
    "vset_lane_s32",
    "vsetq_lane_s32",
    "vsetq_lane_s64",
    "vset_lane_u8",
    "vsetq_lane_u8",
    "vset_lane_u16",
    "vsetq_lane_u16",
    "vset_lane_u32",
    "vsetq_lane_u32",
    "vsetq_lane_u64",
    "vset_lane_p8",
    "vsetq_lane_p8",
    "vset_lane_p16",
    "vsetq_lane_p16",
    "vset_lane_p64",
    "vset_lane_s64",
    "vset_lane_u64",
    "vsetq_lane_p64",
    "vsha1cq_u32",
    "vsha1h_u32",
    "vsha1mq_u32",
    "vsha1pq_u32",
    "vsha1su0q_u32",
    "vsha1su1q_u32",
    "vsha256h2q_u32",
    "vsha256hq_u32",
    "vsha256su0q_u32",
    "vsha256su1q_u32",
    "vshl_n_s8",
    "vshlq_n_s8",
    "vshl_n_s16",
    "vshlq_n_s16",
    "vshl_n_s32",
    "vshlq_n_s32",
    "vshl_n_s64",
    "vshlq_n_s64",
    "vshl_n_u8",
    "vshlq_n_u8",
    "vshl_n_u16",
    "vshlq_n_u16",
    "vshl_n_u32",
    "vshlq_n_u32",
    "vshl_n_u64",
    "vshlq_n_u64",
    "vshl_s8",
    "vshlq_s8",
    "vshl_s16",
    "vshlq_s16",
    "vshl_s32",
    "vshlq_s32",
    "vshl_s64",
    "vshlq_s64",
    "vshl_u8",
    "vshlq_u8",
    "vshl_u16",
    "vshlq_u16",
    "vshl_u32",
    "vshlq_u32",
    "vshl_u64",
    "vshlq_u64",
    "vshll_n_s16",
    "vshll_n_s32",
    "vshll_n_s8",
    "vshll_n_u16",
    "vshll_n_u32",
    "vshll_n_u8",
    "vshr_n_s8",
    "vshrq_n_s8",
    "vshr_n_s16",
    "vshrq_n_s16",
    "vshr_n_s32",
    "vshrq_n_s32",
    "vshr_n_s64",
    "vshrq_n_s64",
    "vshr_n_u8",
    "vshrq_n_u8",
    "vshr_n_u16",
    "vshrq_n_u16",
    "vshr_n_u32",
    "vshrq_n_u32",
    "vshr_n_u64",
    "vshrq_n_u64",
    "vshrn_n_s16",
    "vshrn_n_s32",
    "vshrn_n_s64",
    "vshrn_n_u16",
    "vshrn_n_u32",
    "vshrn_n_u64",
    "vsra_n_s8",
    "vsraq_n_s8",
    "vsra_n_s16",
    "vsraq_n_s16",
    "vsra_n_s32",
    "vsraq_n_s32",
    "vsra_n_s64",
    "vsraq_n_s64",
    "vsra_n_u8",
    "vsraq_n_u8",
    "vsra_n_u16",
    "vsraq_n_u16",
    "vsra_n_u32",
    "vsraq_n_u32",
    "vsra_n_u64",
    "vsraq_n_u64",
    "vst1_f16",
    "vst1q_f16",
    "vst1_f16_x2",
    "vst1q_f16_x2",
    "vst1_f16_x2",
    "vst1q_f16_x2",
    "vst1_f16_x3",
    "vst1q_f16_x3",
    "vst1_f16_x3",
    "vst1q_f16_x3",
    "vst1_f16_x4",
    "vst1q_f16_x4",
    "vst1_f16_x4",
    "vst1q_f16_x4",
    "vst1_f32_x2",
    "vst1q_f32_x2",
    "vst1_f32_x2",
    "vst1q_f32_x2",
    "vst1_f32_x3",
    "vst1q_f32_x3",
    "vst1_f32_x4",
    "vst1q_f32_x4",
    "vst1_f32_x4",
    "vst1q_f32_x4",
    "vst1_lane_f16",
    "vst1q_lane_f16",
    "vst1_lane_f32",
    "vst1q_lane_f32",
    "vst1_lane_s8",
    "vst1q_lane_s8",
    "vst1_lane_s16",
    "vst1q_lane_s16",
    "vst1_lane_s32",
    "vst1q_lane_s32",
    "vst1q_lane_s64",
    "vst1_lane_u8",
    "vst1q_lane_u8",
    "vst1_lane_u16",
    "vst1q_lane_u16",
    "vst1_lane_u32",
    "vst1q_lane_u32",
    "vst1q_lane_u64",
    "vst1_lane_p8",
    "vst1q_lane_p8",
    "vst1_lane_p16",
    "vst1q_lane_p16",
    "vst1_lane_p64",
    "vst1_lane_s64",
    "vst1_lane_u64",
    "vst1_p64_x2",
    "vst1_p64_x3",
    "vst1_p64_x4",
    "vst1q_p64_x2",
    "vst1q_p64_x3",
    "vst1q_p64_x4",
    "vst1_s8_x2",
    "vst1q_s8_x2",
    "vst1_s16_x2",
    "vst1q_s16_x2",
    "vst1_s32_x2",
    "vst1q_s32_x2",
    "vst1_s64_x2",
    "vst1q_s64_x2",
    "vst1_s8_x2",
    "vst1q_s8_x2",
    "vst1_s16_x2",
    "vst1q_s16_x2",
    "vst1_s32_x2",
    "vst1q_s32_x2",
    "vst1_s64_x2",
    "vst1q_s64_x2",
    "vst1_s8_x3",
    "vst1q_s8_x3",
    "vst1_s16_x3",
    "vst1q_s16_x3",
    "vst1_s32_x3",
    "vst1q_s32_x3",
    "vst1_s64_x3",
    "vst1q_s64_x3",
    "vst1_s8_x3",
    "vst1q_s8_x3",
    "vst1_s16_x3",
    "vst1q_s16_x3",
    "vst1_s32_x3",
    "vst1q_s32_x3",
    "vst1_s64_x3",
    "vst1q_s64_x3",
    "vst1_s8_x4",
    "vst1q_s8_x4",
    "vst1_s16_x4",
    "vst1q_s16_x4",
    "vst1_s32_x4",
    "vst1q_s32_x4",
    "vst1_s64_x4",
    "vst1q_s64_x4",
    "vst1_s8_x4",
    "vst1q_s8_x4",
    "vst1_s16_x4",
    "vst1q_s16_x4",
    "vst1_s32_x4",
    "vst1q_s32_x4",
    "vst1_s64_x4",
    "vst1q_s64_x4",
    "vst1_u8_x2",
    "vst1_u8_x3",
    "vst1_u8_x4",
    "vst1q_u8_x2",
    "vst1q_u8_x3",
    "vst1q_u8_x4",
    "vst1_u16_x2",
    "vst1_u16_x3",
    "vst1_u16_x4",
    "vst1q_u16_x2",
    "vst1q_u16_x3",
    "vst1q_u16_x4",
    "vst1_u32_x2",
    "vst1_u32_x3",
    "vst1_u32_x4",
    "vst1q_u32_x2",
    "vst1q_u32_x3",
    "vst1q_u32_x4",
    "vst1_u64_x2",
    "vst1_u64_x3",
    "vst1_u64_x4",
    "vst1q_u64_x2",
    "vst1q_u64_x3",
    "vst1q_u64_x4",
    "vst1_p8_x2",
    "vst1_p8_x3",
    "vst1_p8_x4",
    "vst1q_p8_x2",
    "vst1q_p8_x3",
    "vst1q_p8_x4",
    "vst1_p16_x2",
    "vst1_p16_x3",
    "vst1_p16_x4",
    "vst1q_p16_x2",
    "vst1q_p16_x3",
    "vst1q_p16_x4",
    "vst1q_lane_p64",
    "vst2_f16",
    "vst2q_f16",
    "vst2_f16",
    "vst2q_f16",
    "vst2_f32",
    "vst2q_f32",
    "vst2_s8",
    "vst2q_s8",
    "vst2_s16",
    "vst2q_s16",
    "vst2_s32",
    "vst2q_s32",
    "vst2_f32",
    "vst2q_f32",
    "vst2_s8",
    "vst2q_s8",
    "vst2_s16",
    "vst2q_s16",
    "vst2_s32",
    "vst2q_s32",
    "vst2_lane_f16",
    "vst2q_lane_f16",
    "vst2_lane_f16",
    "vst2q_lane_f16",
    "vst2_lane_f32",
    "vst2q_lane_f32",
    "vst2_lane_s8",
    "vst2_lane_s16",
    "vst2q_lane_s16",
    "vst2_lane_s32",
    "vst2q_lane_s32",
    "vst2_lane_f32",
    "vst2q_lane_f32",
    "vst2_lane_s8",
    "vst2_lane_s16",
    "vst2q_lane_s16",
    "vst2_lane_s32",
    "vst2q_lane_s32",
    "vst2_lane_u8",
    "vst2_lane_u16",
    "vst2q_lane_u16",
    "vst2_lane_u32",
    "vst2q_lane_u32",
    "vst2_lane_p8",
    "vst2_lane_p16",
    "vst2q_lane_p16",
    "vst2_p64",
    "vst2_s64",
    "vst2_s64",
    "vst2_u64",
    "vst2_u8",
    "vst2q_u8",
    "vst2_u16",
    "vst2q_u16",
    "vst2_u32",
    "vst2q_u32",
    "vst2_p8",
    "vst2q_p8",
    "vst2_p16",
    "vst2q_p16",
    "vst3_f16",
    "vst3q_f16",
    "vst3_f16",
    "vst3q_f16",
    "vst3_f32",
    "vst3q_f32",
    "vst3_s8",
    "vst3q_s8",
    "vst3_s16",
    "vst3q_s16",
    "vst3_s32",
    "vst3q_s32",
    "vst3_f32",
    "vst3q_f32",
    "vst3_s8",
    "vst3q_s8",
    "vst3_s16",
    "vst3q_s16",
    "vst3_s32",
    "vst3q_s32",
    "vst3_lane_f16",
    "vst3q_lane_f16",
    "vst3_lane_f16",
    "vst3q_lane_f16",
    "vst3_lane_f32",
    "vst3q_lane_f32",
    "vst3_lane_s8",
    "vst3_lane_s16",
    "vst3q_lane_s16",
    "vst3_lane_s32",
    "vst3q_lane_s32",
    "vst3_lane_f32",
    "vst3q_lane_f32",
    "vst3_lane_s8",
    "vst3_lane_s16",
    "vst3q_lane_s16",
    "vst3_lane_s32",
    "vst3q_lane_s32",
    "vst3_lane_u8",
    "vst3_lane_u16",
    "vst3q_lane_u16",
    "vst3_lane_u32",
    "vst3q_lane_u32",
    "vst3_lane_p8",
    "vst3_lane_p16",
    "vst3q_lane_p16",
    "vst3_p64",
    "vst3_s64",
    "vst3_s64",
    "vst3_u64",
    "vst3_u8",
    "vst3q_u8",
    "vst3_u16",
    "vst3q_u16",
    "vst3_u32",
    "vst3q_u32",
    "vst3_p8",
    "vst3q_p8",
    "vst3_p16",
    "vst3q_p16",
    "vst4_f16",
    "vst4q_f16",
    "vst4_f16",
    "vst4q_f16",
    "vst4_f32",
    "vst4q_f32",
    "vst4_s8",
    "vst4q_s8",
    "vst4_s16",
    "vst4q_s16",
    "vst4_s32",
    "vst4q_s32",
    "vst4_f32",
    "vst4q_f32",
    "vst4_s8",
    "vst4q_s8",
    "vst4_s16",
    "vst4q_s16",
    "vst4_s32",
    "vst4q_s32",
    "vst4_lane_f16",
    "vst4q_lane_f16",
    "vst4_lane_f16",
    "vst4q_lane_f16",
    "vst4_lane_f32",
    "vst4q_lane_f32",
    "vst4_lane_s8",
    "vst4_lane_s16",
    "vst4q_lane_s16",
    "vst4_lane_s32",
    "vst4q_lane_s32",
    "vst4_lane_f32",
    "vst4q_lane_f32",
    "vst4_lane_s8",
    "vst4_lane_s16",
    "vst4q_lane_s16",
    "vst4_lane_s32",
    "vst4q_lane_s32",
    "vst4_lane_u8",
    "vst4_lane_u16",
    "vst4q_lane_u16",
    "vst4_lane_u32",
    "vst4q_lane_u32",
    "vst4_lane_p8",
    "vst4_lane_p16",
    "vst4q_lane_p16",
    "vst4_p64",
    "vst4_s64",
    "vst4_s64",
    "vst4_u64",
    "vst4_u8",
    "vst4q_u8",
    "vst4_u16",
    "vst4q_u16",
    "vst4_u32",
    "vst4q_u32",
    "vst4_p8",
    "vst4q_p8",
    "vst4_p16",
    "vst4q_p16",
    "vsub_f16",
    "vsubq_f16",
    "vsub_s64",
    "vsubq_s64",
    "vsub_u64",
    "vsubq_u64",
    "vsubhn_high_s16",
    "vsubhn_high_s32",
    "vsubhn_high_s64",
    "vsubhn_high_u16",
    "vsubhn_high_u32",
    "vsubhn_high_u64",
    "vsubhn_s16",
    "vsubhn_s32",
    "vsubhn_s64",
    "vsubhn_u16",
    "vsubhn_u32",
    "vsubhn_u64",
    "vsubl_s8",
    "vsubl_s16",
    "vsubl_s32",
    "vsubl_u8",
    "vsubl_u16",
    "vsubl_u32",
    "vsubw_s8",
    "vsubw_s16",
    "vsubw_s32",
    "vsubw_u8",
    "vsubw_u16",
    "vsubw_u32",
    "vsudot_lane_s32",
    "vsudot_lane_s32",
    "vsudotq_lane_s32",
    "vsudotq_lane_s32",
    "vsudot_laneq_s32",
    "vsudotq_laneq_s32",
    "vtrn_f16",
    "vtrnq_f16",
    "vtrn_f32",
    "vtrn_s32",
    "vtrn_u32",
    "vtrnq_f32",
    "vtrn_s8",
    "vtrnq_s8",
    "vtrn_s16",
    "vtrnq_s16",
    "vtrnq_s32",
    "vtrn_u8",
    "vtrnq_u8",
    "vtrn_u16",
    "vtrnq_u16",
    "vtrnq_u32",
    "vtrn_p8",
    "vtrnq_p8",
    "vtrn_p16",
    "vtrnq_p16",
    "vtst_s8",
    "vtstq_s8",
    "vtst_s16",
    "vtstq_s16",
    "vtst_s32",
    "vtstq_s32",
    "vtst_p8",
    "vtstq_p8",
    "vtst_p16",
    "vtstq_p16",
    "vtst_u8",
    "vtstq_u8",
    "vtst_u16",
    "vtstq_u16",
    "vtst_u32",
    "vtstq_u32",
    "vusdot_lane_s32",
    "vusdot_lane_s32",
    "vusdotq_lane_s32",
    "vusdotq_lane_s32",
    "vusdot_laneq_s32",
    "vusdot_laneq_s32",
    "vusdotq_laneq_s32",
    "vusdotq_laneq_s32",
    "vusdot_s32",
    "vusdotq_s32",
    "vusmmlaq_s32",
    "vuzp_f16",
    "vuzpq_f16",
    "vuzp_f32",
    "vuzp_s32",
    "vuzp_u32",
    "vuzpq_f32",
    "vuzp_s8",
    "vuzpq_s8",
    "vuzp_s16",
    "vuzpq_s16",
    "vuzpq_s32",
    "vuzp_u8",
    "vuzpq_u8",
    "vuzp_u16",
    "vuzpq_u16",
    "vuzpq_u32",
    "vuzp_p8",
    "vuzpq_p8",
    "vuzp_p16",
    "vuzpq_p16",
    "vzip_f16",
    "vzipq_f16",
    "vzip_f32",
    "vzip_s32",
    "vzip_u32",
    "vzip_s8",
    "vzip_s16",
    "vzip_u8",
    "vzip_u16",
    "vzip_p8",
    "vzip_p16",
    "vzipq_f32",
    "vzipq_s8",
    "vzipq_s16",
    "vzipq_s32",
    "vzipq_u8",
    "vzipq_u16",
    "vzipq_u32",
    "vzipq_p8",
    "vzipq_p16",
    "__rndr",
    "__rndrrs",
];
